﻿//using DevExpress.Data.Filtering;
//using DevExpress.Mvvm;
//using DevExpress.Mvvm.Native;
//using HandyControl.Controls;
//using log4net;
//using Newtonsoft.Json;
//using Newtonsoft.Json.Linq;
//using PlaceOrder_Core.Helper;
//using PlaceOrder_Core.Models.QuanYi;
//using PlaceOrder_Core.PlaceOrderModels;
//using PlaceOrder_Core.Services.Instances;
//using PlaceOrder_Core.Services.Interfaces;
//using PlaceOrder_Server.Events;
//using PlaceOrder_Server.Helper;
//using PlaceOrder_Shared.Models.Common;
//using PlaceOrder_Shared.Models.Daily;
//using PlaceOrder_Shared.Models.Trade;
//using Prism.Commands;
//using Prism.DryIoc;
//using Prism.Events;
//using Prism.Mvvm;
//using Prism.Services.Dialogs;
//using System.Collections.Concurrent;
//using System.Collections.ObjectModel;
//using System.Globalization;
//using System.IO;
//using System.Net.Http;
//using System.Runtime.InteropServices;
//using System.Text;
//using System.Threading;
//using WindowsInput;
//using WindowsInput.Native;
//using static System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel;
//using BindableBase = Prism.Mvvm.BindableBase;
//using DelegateCommand = Prism.Commands.DelegateCommand;
//namespace PlaceOrder_Server.ViewModels
//{
//    public class IndexServerViewModel : BindableBase
//    {
//        private readonly ILog _log;
//        private readonly IDailyData _dailyData;
//        private readonly IUserHelper _userHelper;
//        private ServerWebSocketHelper serverWebSocketFromClient;
//        private ServerWebSocketHelper serverWebSocketFromAdmin;
//        private ClientWebSocketHelper clientWebSocketToLily;
//        private static List<ChatReceiver> Receivers = new List<ChatReceiver>();
//        private int CurrentDailyID = 0;
//        private bool AdminIsConnected = false; //是否连接到管理端

//        public DelegateCommand TestCommand { get; set; }
//        public DelegateCommand TestCatchCommand { get; set; }
//        public DelegateCommand ClearMessageCommand { get; set; }


//        private readonly IEventAggregator _eventAggregator;
//        //ILog log, IDailyData dailyData, IEventAggregator eventAggregator, IUserHelper userHelper


//        async Task Login()
//        {
//            string UserName = "admin";
//            string PassWord = "admin123";
//            AppLog.WriteInfo("登录成功哦");
//            if (string.IsNullOrWhiteSpace(UserName) || string.IsNullOrWhiteSpace(PassWord))
//            {
//                Growl.Info("请输入用户名/密码", "LoginMsg");
//                return;
//            }

//            UserInfo userInfo = new UserInfo();
//            userInfo.userName = UserName;
//            userInfo.password = PassWord;

//            var loginResult = await _userHelper.Login(userInfo, 0);

//            if (loginResult.Item2)
//            {
//                if (UserHelper.UserName != "admin")
//                {
//                    Growl.Info("请使用admin登录账户", "LoginMsg");
//                    return;
//                }
//            }
//            else
//            {
//                Growl.Error("登录异常,请检查用户名及密码", "LoginMsg");
//            }

//            if (loginResult.Item1 != null && loginResult.Item2 == true)
//            {
//                string msg = "登录成功。" + "账户为：" + UserName;
//                AppLog.WriteInfo(msg);
//            }
//            else
//            {
//                string msg = "登录成功。" + "账户为：" + UserName;
//                AppLog.WriteError(msg);
//            }
//        }
//        public IndexServerViewModel(ILog log, IDailyData dailyData, IEventAggregator eventAggregator, IUserHelper userHelper)
//        {
//            // 在构造函数调用完成后执行异步登录
//            _eventAggregator = eventAggregator;
//            _log = log;
//            _dailyData = dailyData;
//            _userHelper = userHelper;
//            Task.Run(async () => await Login());

//            Thread.Sleep(2000);

//            Receivers = _dailyData.GetChatReceivers();
//            RegisterHotKey();//快捷键关闭服务

//            UserData = _dailyData.GetAllUsers().ToObservableCollection();
//            InitValue();
//            InitChatName();
//            InitCommand();




//            Thread normalServiceThread = new Thread(StartNormalServerService); //服务端（接收客户端消息）38888端口
//            normalServiceThread.Start();


//            Thread adminServiceThread = new Thread(StartAdminServerService); //服务端（接收管理端消息）38889端口
//            adminServiceThread.Start();

//            Thread lilyServiceThread = new Thread(ConnectLiuService); //对接刘老师接口
//            lilyServiceThread.Start();

//            //StartCaptureMessageService();
//            Thread captureThread = new Thread(StartCaptureMessageService);//捕获消息服务
//            captureThread.Start();



//            this.BrokerList = Receivers.Select(o => o.ChatId).Distinct().ToList();
//            TestCommand = new DelegateCommand(() =>
//            {

//                //this.Websocket_LilyInformEvent("1");
//                this.ModifyInterval();

//                //this.SendTestMessageToLily();
//            });


//        }

//        private void InitChatName()
//        {
//            this.ChatName = _dailyData.GetChatReceivers().Select(o => o.Target).Distinct().ToList();
//        }

//        private void SendTestMessageToLily()
//        {
//            var chatMsg = new ChatMessage() { BrokerId = 2, ChatId = 107, TradeId = 5049, ChatMessageInfo = "T002 bid 240210 2.384 7月9日+0 2k", CreateTime = DateTime.Now };

//            this.SaveMessageToLily(0, chatMsg);

//        }
//        #region 我的服务端连接刘老师服务端（接收推送）
//        private System.Threading.Timer reconnectLilyTimer;
//        private bool isReconnectingLily = false; // 标记是否正在重连，用于避免重复触发重连操作
//        private void ConnectLiuService()
//        {
//            try
//            {
//                clientWebSocketToLily = new ClientWebSocketHelper();

//                clientWebSocketToLily.LilyInformEvent += Websocket_LilyInformEvent;

//                clientWebSocketToLily.LilyDisconnectEvent += ClientWebSocketToLily_LilyDisconnectEvent;
//                clientWebSocketToLily.SubscribeLilyServerData(1);
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("ConnectLiuService 异常" + ex.StackTrace + ex.Message);
//            }
//        }

//        private void ClientWebSocketToLily_LilyDisconnectEvent()
//        {
//            AppLog.WriteFatal("服务端和lily断连");
//            try
//            {

//                // 可以在这里添加重连逻辑
//                // 检查是否正在重连，避免重复触发
//                if (!isReconnectingLily)
//                {
//                    isReconnectingLily = true;
//                    // 开始定时重连
//                    StartReconnectLilyTimer();
//                }
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteFatal("ClientWebSocketToLily_LilyDisconnectEvent" + ex.Message + ex.StackTrace);
//            }
//        }
//        private void StartReconnectLilyTimer()
//        {
//            // 创建一个 1 秒间隔的定时器
//            AppLog.WriteFatal("StartReconnectLilyTimer创建一个 1 秒间隔的定时器");
//            reconnectLilyTimer = new System.Threading.Timer(TryReconnect, null, 1000, Timeout.Infinite);
//        }
//        private void TryReconnect(object test)
//        {
//            try
//            {
//                // 在重新连接之前可以进行一些清理操作
//                clientWebSocketToLily?.Dispose(); // 关闭当前的 WebSocket 连接，如果有的话

//                // 重新创建新的 ClientWebSocketHelper 实例
//                clientWebSocketToLily = new ClientWebSocketHelper();
//                //clientWebSocketToLily.SubscribeLilyServerData();
//                clientWebSocketToLily.LilyInformEvent -= Websocket_LilyInformEvent;

//                clientWebSocketToLily.LilyInformEvent += Websocket_LilyInformEvent;
//                clientWebSocketToLily.LilyDisconnectEvent -= ClientWebSocketToLily_LilyDisconnectEvent;

//                clientWebSocketToLily.LilyDisconnectEvent += ClientWebSocketToLily_LilyDisconnectEvent;

//                // 连接到 Lily 服务器
//                clientWebSocketToLily.SubscribeLilyServerData(1); // 这里需要实现 Connect 方法来连接到 WebSocket 服务器

//                // 重连成功后重置标志
//                isReconnectingLily = false;
//                AppLog.WriteInfo("重新连接到 Lily 服务器成功");
//                AppLog.WriteFatal("重新连接到 Lily 服务器成功");
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError($"重连失败: {ex.Message}");
//                StartReconnectLilyTimer();
//                // 可以选择在此处添加重试逻辑，例如延时后再次尝试重连
//            }
//        }


//        // 全局定义一个集合用于存储已处理的消息
//        private static HashSet<string> processedQiangPingMessages = new HashSet<string>();

//        private static string GenerateUniqueKey(string userID, string brokerId, string tradeId, string messageSend)
//        {
//            return $"{userID}_{brokerId}_{tradeId}_{messageSend}";
//        }


//        /// <summary>
//        /// 对接刘老师websocket的核心方法
//        /// </summary>
//        /// <param name="Message"></param>
//        private void Websocket_LilyInformEvent(string Message)
//        {
//            try
//            {
//                // 解析 JSON 数据
//                JObject jsonMessage = JObject.Parse(Message);

//                // 提取信息
//                string dataKey = jsonMessage["dataKey"]?.ToString();
//                string dataType = jsonMessage["dataType"]?.ToString();
//                AppLog.WriteFatal("lily -服务端 所有消息" + Message);

//                switch (dataType)
//                {
//                    case "pong":
//                        AppLog.WriteFatal("收到心跳包" + dataKey + dataType);
//                        return;
//                        break;
//                    #region 丢弃不做处理的
//                    case "tradeamountlimit":
//                        return;
//                        break;
//                    #endregion


//                    //发送撤单/改价指令给中介
//                    case "qiangping":

//                        var data = jsonMessage["data"];

//                        string userID = data["yanjiuyuanId"]?.ToString();
//                        string brokerId = data["brokerID"]?.ToString();
//                        string messageSend = data["message"]?.ToString();
//                        string tradeId = data["userTradeID"]?.ToString();

//                        string uniqueKey = GenerateUniqueKey(userID, brokerId, tradeId, messageSend);
//                        QuanYiOrderServerResponseClass qsr = new QuanYiOrderServerResponseClass();
//                        if (processedQiangPingMessages.Contains(uniqueKey))
//                        {
//                            AppLog.WriteFatal("重复消息，舍弃: " + uniqueKey);
//                            return;
//                        }

//                        processedQiangPingMessages.Add(uniqueKey);

//                        qsr.Trade = new UserTrade();
//                        qsr.Trade.ChatID = userID;

//                        if (Receivers == null)
//                        {
//                            Receivers = _dailyData.GetChatReceivers();
//                        }
//                        qsr.Trade.ChannelID = Receivers.Where(o => o.Brokerid == int.Parse(brokerId)).FirstOrDefault().ChannelId;
//                        qsr.Trade.UserTradeID = Convert.ToInt64(tradeId);
//                        qsr.Trade.BrokerID = int.Parse(brokerId);
//                        qsr.Message = messageSend;



//                        //询价单发送给lily
//                        if (qsr != null)
//                        {

//                            SendMessage(qsr, 1);
//                            ChatMessage chatMessage = new ChatMessage() { BrokerId = qsr.Trade.BrokerID, ChannelId = qsr.Trade.ChannelID, ChatMessageInfo = qsr.Message, TradeId = qsr.Trade.UserTradeID, ChatId = int.Parse(qsr.Trade.ChatID) };
//                            AppLog.WriteFatal($"发送强平单！！给lily,brokerId={chatMessage.BrokerId},channelId={chatMessage.ChannelId},消息={chatMessage.ChatMessageInfo},TradeId={chatMessage.TradeId},ChatID={chatMessage.ChatId}");
//                            this.SaveMessageToLily(0, chatMessage);
//                        }
//                        break;


//                    //case "chat_message":
//                    //    // 创建一个唯一标识符（例如组合时间戳和消息内容）
//                    //    // 格式化 createTime 为 "yyyy-MM-dd HH:mm:ss"
//                    //    RootFromLily root = jsonMessage.ToObject<RootFromLily>();
//                    //    ChatDataFromLily item = root.Data;
//                    //    string formattedCreateTime = new DateTime(item.CreateTime.Year, item.CreateTime.MonthValue, item.CreateTime.DayOfMonth, item.CreateTime.Hour, item.CreateTime.Minute, item.CreateTime.Second)
//                    //                                 .ToString("yyyy-MM-dd HH:mm:ss");
//                    //    List<ChatMessage> newMessages = new List<ChatMessage>();


//                    //    this.WebSocketInfo += "聊天消息" + item.ChatMessage + "\r\n";
//                    //    int direction = item.Direction;
//                    //    int brokerId = item.BrokerId;
//                    //    string chatMsg = item.ChatMessage;
//                    //    int chatId = item.ChatId;
//                    //    string tradeId = item.TradeId;
//                    //    //string brokerName = item.BrokerName;
//                    //    // 将字符串转换为 DateTime 类型
//                    //    DateTime createTime;
//                    //    if (DateTime.TryParse(formattedCreateTime, out createTime))
//                    //    {
//                    //        // 转换成功
//                    //        // Console.WriteLine(createTime);
//                    //    }
//                    //    else
//                    //    {
//                    //        // 转换失败，处理错误
//                    //        AppLog.WriteError("转换错误");
//                    //        Console.WriteLine("Invalid date format");
//                    //    }

//                    //    // 创建一个唯一标识符（例如组合时间戳和消息内容）
//                    //    string uniqueIdentifier = $"{formattedCreateTime}_{item.ChatMessage}";

//                    //    // 检查是否已经处理过该消息
//                    //    if (!processedMessages.Contains(uniqueIdentifier))
//                    //    {
//                    //        // 获取中介名称
//                    //        string brokerName = ChatReceivers.Where(o => o.Brokerid == item.BrokerId).FirstOrDefault()?.Company;

//                    //        // 生成消息信息
//                    //        string chatInfo = $"消息内容：{item.ChatMessage}\r\n" +
//                    //                          $"时间：{formattedCreateTime}\r\n" +
//                    //                          $"中介：{brokerName}";
//                    //        Growl.InfoGlobal($"收到一条新消息：{chatInfo}");

//                    //        // 添加到已处理集合中
//                    //        processedMessages.Add(uniqueIdentifier);
//                    //        long parsedTradeId = 0;
//                    //        if (!string.IsNullOrEmpty(tradeId) && !long.TryParse(tradeId, out parsedTradeId))
//                    //        {
//                    //            parsedTradeId = 0;
//                    //        }
//                    //        var chatMsgModel = new ChatMessage() { Direction = (short?)direction, ChatMessageInfo = chatMsg, CreateTime = createTime, BrokerId = brokerId, BrokerName = brokerName ?? "未知", ChatId = chatId, TradeId = parsedTradeId };
//                    //        newMessages.Add(chatMsgModel);
//                    //    }
//                    //    //string brokerName = ChatReceivers.Where(o=>o.Brokerid==item.BrokerId).FirstOrDefault().Company;
//                    //    //string chatinfo = $"消息内容：{item.ChatMessageInfo}\r\n" +
//                    //    //    $"时间：{item.CreateTime}\r\n" +
//                    //    //    $"中介：{brokerName}";
//                    //    //item.BrokerName = brokerName;
//                    //    //Growl.InfoGlobal($"收到一条新消息：{chatinfo}");


//                    //    // 仅对新的消息列表进行发送
//                    //    if (newMessages.Count > 0)
//                    //    {
//                    //        //Messenger.Default.Send(newMessages, MessageToken.NewChatMessageIn);
//                    //        Messenger.Default.Send(newMessages, MessageToken.SendChatMessage);
//                    //        if (newMessages[0].Direction == 1)
//                    //        {
//                    //            SearchHandle();
//                    //        }
//                    //    }
//                    //    break;
//                    case "chat_message":
//                    case "accept_bond_1":
//                    case "accept_bond_0":
//                    case "deal_bond_0":
//                    case "deal_bond_1":
//                    case "request_cancel_bond_0":
//                    case "request_cancel_bond_1":
//                    case "confirm_cancel_bond_0":
//                    case "confirm_cancel_bond_1":
//                    case "deny_cancel_bond_0":
//                    case "deny_cancel_bond_1":
//                    case "xiugaichangedeny_bond_0":
//                    case "xiugaichangedeny_bond_1":
//                    case "usertradechange_bond_0":
//                    case "usertradechange_bond_1":
//                        return;
//                        break;

//                    case "xunjiachangerequest_bond_1":
//                    case "xunjiachangerequest_bond_0":
//                        //string info1 = LilyMessageConverterHelper.ConvertToRealMessage(dataType);
//                        //Growl.InfoGlobal($"系统收到改价消息 —— {info1}");
//                        //SearchHandle();
//                        break;
//                    default:
//                        AppLog.WriteFatal("lily -orderlistviewmodel 其余消息" + Message);
//                        //this.WebSocketInfo = "lily -orderlistviewmodel 其余消息" + Message;
//                        // SearchHandle();
//                        break;
//                }

//                //OrderListViewModel.ShowQiangPing(qiangPingMessage);

//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("收到强平异常Websocket_InformEvent" + ex.Message + ex.StackTrace);
//            }
//        }



//        private void ClientWebSocketToLily_QiangpingEvent(PlaceOrder_Shared.ModelsToLily.QiangPingOrder qiangPingOrder)
//        {
//        }

//        #endregion

//        private void InitCommand()
//        {
//            ClearChatDataCommand = new DelegateCommand(ClearChatData);

//            TestCatchCommand = new DelegateCommand(TestCatch);

//            ClearMessageCommand = new DelegateCommand(() =>
//            {
//                this.ChatMessageLog = null;
//            });
//        }

//        private void ClearChatData()
//        {
//            if (this.SelectedBrokerName == null)
//            {
//                Growl.ErrorGlobal("未选择中介请检查");
//                return;
//            }
//            if (this.SelectedStartDate == null)
//            {
//                Growl.ErrorGlobal("请选择时间");
//                return;
//            }
//            int brokerId = (int)Receivers.Where(o => o.ChatId == this.SelectedBrokerName).FirstOrDefault().Brokerid;
//            _dailyData.DelChatMessageList(brokerId, this.SelectedStartDate);
//        }

//        private async void InitValue()
//        {
//            //Trades = await Task.Run(() => _dailyData.GetUserTrades().ToObservableCollection());

//            //PlaceOrder_Core.Services.Instances.DailyData.ChannelId = _dailyData.GetChannelId();
//            try
//            {
//                var tradesNew = UserHelper.FindAllXunJiaOrdersAsync().Result;
//                var tradeModels = tradesNew.Select(trade => new UserTrade
//                {
//                    // 根据需要设置 UserTrade 对象的属性
//                    // 例如：
//                    BrokerID = trade.BrokerId,
//                    Status = trade.Status,
//                    Price = (decimal)trade.Price,
//                    Volume = (int.Parse)(trade.Volume),
//                    OnHoldVolume = (int.Parse)(trade.RestVolume),
//                    TsCode = trade.Tscode,
//                    Time = trade.CreateTime,
//                    DealType = trade.Direction == "bond_0" ? "买入" : (trade.Direction == "bond_1" ? "卖出" : "未知"), // 根据Direction设置DealType
//                    UserTradeID = trade.UserTradeId,
//                    ChannelID = trade.ChannelId,
//                    DeliveryDate = DateOnly.FromDateTime(trade.DeliveryTime),
//                    DeliverySpeed = trade.DeliverySpeed,
//                    Target = trade.Target
//                    // 其他属性赋值
//                }).ToList();

//                PrismApplication.Current.Dispatcher.Invoke(() => { Trades = tradeModels.ToObservableCollection(); });
//                Greet();
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("InitValue异常" + ex.Message);
//            }


//        }
//        #region 命令
//        public DelegateCommand ClearChatDataCommand { get; set; }

//        #endregion


//        #region 依赖属性

//        /// <summary>
//        /// 清空的开始时间
//        /// </summary>
//        private DateTime _selectedStartDate = DateTime.Now;

//        public DateTime SelectedStartDate
//        {
//            get { return _selectedStartDate; }
//            set
//            {
//                _selectedStartDate = value;
//                RaisePropertyChanged();
//            }
//        }
//        private string selectedBrokerName;

//        public string SelectedBrokerName
//        {
//            get { return selectedBrokerName; }
//            set { selectedBrokerName = value; RaisePropertyChanged(); }
//        }


//        /// <summary>
//        /// 中介列表
//        /// </summary>
//        private List<string> brokerList;

//        public List<string> BrokerList
//        {
//            get { return brokerList; }
//            set { brokerList = value; RaisePropertyChanged(); }
//        }


//        private ObservableCollection<TradeSimUser> userData;
//        public ObservableCollection<TradeSimUser> UserData
//        {
//            get => userData;
//            set
//            {
//                if (userData != value)
//                {
//                    userData = value;
//                    RaisePropertyChanged();
//                }
//            }
//        }


//        private ObservableCollection<UserTrade> trades;
//        public ObservableCollection<UserTrade> Trades
//        {
//            get => trades;
//            set
//            {
//                if (trades != value)
//                {
//                    trades = value;
//                    RaisePropertyChanged();
//                }
//            }
//        }



//        /// <summary>
//        /// 捕获聊天记录的日志
//        /// </summary>
//        private string chatMessageLog;

//        public string ChatMessageLog
//        {
//            get { return chatMessageLog; }
//            set { chatMessageLog = value; RaisePropertyChanged(); }
//        }


//        /// <summary>
//        /// 下单的日志
//        /// </summary>
//        private string orderLog;

//        public string OrderLog
//        {
//            get { return orderLog; }
//            set { orderLog = value; RaisePropertyChanged(); }
//        }

//        #endregion


//        #region 服务端——对接客户端服务
//        public void StartNormalServerService()
//        {
//            try
//            {
//                serverWebSocketFromClient = new ServerWebSocketHelper(_dailyData);
//                serverWebSocketFromClient.QuanYiOrderServerMessageEvent += Websocket_QuanYiServerMessageEvent;
//                serverWebSocketFromClient.SubscribeLilyTradeEvent += WebSocketHelper_SubscribeLilyTradeEvent;
//                serverWebSocketFromClient.serverWebSocketStart();
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("StartNormalServerService异常" + ex.StackTrace + ex.Message);
//            }

//        }

//        private void WebSocketHelper_SubscribeLilyTradeEvent(LilyTradeModel Trade)
//        {
//            try
//            {
//                UserTrade t = Trades.SingleOrDefault(x => x.UserTradeID == int.Parse(Trade.userTradeId));
//                if (t != null)
//                {
//                    int RestVolume = int.Parse(Trade.restVolume);
//                    if (RestVolume == 0)
//                    {
//                        PrismApplication.Current.Dispatcher.Invoke(() =>
//                        {
//                            Receivers.SingleOrDefault(x => x.Brokerid == t.BrokerID).OrderInProgress = false;

//                        });
//                    }
//                    t.OnHoldVolume = RestVolume;
//                }
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError(ex.Message + "PlaceOrderServer" + "WebSocketHelper_SubscribeLilyTradeEvent" + ex.StackTrace);
//            }
//        }

//        private void Websocket_QuanYiServerMessageEvent(QuanYiOrderServerResponseClass QSR)
//        {
//            try
//            {
//                UserTrade tmpTrade;
//                TradeSimUser user;
//                ChatReceiver chat;
//                int result;
//                int UserTradeID;
//                string msg;
//                int ActualVolume;

//                //var tradesNew =  UserHelper.FindAllXunJiaOrdersAsync().Result;
//                //var tradeModels = tradesNew.Select(trade => new UserTrade
//                //{
//                //    // 根据需要设置 UserTrade 对象的属性
//                //    // 例如：
//                //    BrokerID = trade.BrokerId,
//                //    Status = trade.Status,
//                //    Price = (decimal)trade.Price,
//                //    Volume = (int.Parse)(trade.Volume),
//                //    OnHoldVolume = (int.Parse)(trade.RestVolume),
//                //    TsCode = trade.Tscode,
//                //    Time = trade.CreateTime,
//                //    DealType = trade.Direction == "bond_0" ? "买入" : (trade.Direction == "bond_1" ? "卖出" : "未知"), // 根据Direction设置DealType
//                //    UserTradeID = trade.UserTradeId,
//                //    ChannelID = trade.ChannelId,
//                //    DeliveryDate = DateOnly.FromDateTime(trade.DeliveryTime),
//                //    DeliverySpeed = trade.DeliverySpeed,
//                //    Target = trade.Target
//                //    // 其他属性赋值
//                //}).ToList();

//                //PrismApplication.Current.Dispatcher.Invoke(() => { Trades = tradeModels.ToObservableCollection(); });
//                // 异步获取数据
//                var tradesNew = UserHelper.FindAllXunJiaOrdersAsync().Result;

//                if (tradesNew != null)
//                {
//                    // 使用并行化处理数据
//                    var tradeModels = tradesNew.AsParallel().Select(trade => new UserTrade
//                    {
//                        BrokerID = trade.BrokerId,
//                        Status = trade.Status,
//                        Price = (decimal)trade.Price,
//                        Volume = int.Parse(trade.Volume),
//                        OnHoldVolume = int.Parse(trade.RestVolume),
//                        TsCode = trade.Tscode,
//                        Time = trade.CreateTime,
//                        DealType = trade.Direction == "bond_0" ? "买入" : (trade.Direction == "bond_1" ? "卖出" : "未知"),
//                        UserTradeID = trade.UserTradeId,
//                        ChannelID = trade.ChannelId,
//                        DeliveryDate = DateOnly.FromDateTime(trade.DeliveryTime),
//                        DeliverySpeed = trade.DeliverySpeed,
//                        Target = trade.Target
//                    }).ToList();

//                    // 在后台线程更新UI
//                    PrismApplication.Current.Dispatcher.Invoke(() =>
//                    {
//                        Trades = tradeModels.ToObservableCollection();
//                    });
//                }
//                else
//                {
//                    AppLog.WriteFatal("未能获取交易数据");
//                }
//                switch (QSR.DataType)
//                {
//                    case QuanYiServerBaseClass.DataTypeEnum.Login:
//                        //user = UserData.Single(x => x.UserID == QSR.UserID);
//                        //PrismApplication.Current.Dispatcher.Invoke(() =>
//                        //{
//                        //    user.Status = 1;
//                        //    user.LoginTime = DateTime.Now;
//                        //});
//                        //QSR.Code = 0;
//                        //QSR.Message = "OK";
//                        //if (user.UserStatus > SimTradeUserStatusEnmu.Normal)
//                        //{
//                        //    QSR.Code = 0;
//                        //    QSR.Message = ((int)user.UserStatus).ToString();
//                        //    QSR.DataType = QuanYiServerBaseClass.DataTypeEnum.UserStatusChange;
//                        //    QSR.Trade = new UserTrade();
//                        //    QSR.Trade.Time = user.DisabledTime;
//                        //}
//                        //OrderLog += "登录相关：" + QSR.UserID + "回应：" + QSR.Message + "\r\n";
//                        //serverWebSocketFromClient?.SendMessageToAdmin(QSR);
//                        break;
//                    case QuanYiServerBaseClass.DataTypeEnum.Logout:

//                        //user = UserData.Single(x => x.UserID == QSR.UserID);
//                        //PrismApplication.Current.Dispatcher.Invoke(() =>
//                        //{
//                        //    user.Status = 0;
//                        //    user.LogoutTime = DateTime.Now;
//                        //});
//                        //OrderLog += "登出相关：" + QSR.UserID + "回应：" + QSR.Message + "\r\n";

//                        return;
//                    case QuanYiServerBaseClass.DataTypeEnum.Order:
//                        try

//                        {
//                            tmpTrade = Trades.SingleOrDefault(x => x.Guid == QSR.Trade.Guid);
//                            if (tmpTrade != null)
//                            {
//                                QSR.Code = 8;
//                                QSR.Message = "订单已存在";
//                                QSR.DataType = QuanYiServerBaseClass.DataTypeEnum.Order;
//                                break;
//                            }

//                            //var s = UserData;
//                            //if (UserData.Single(x => x.UserID == QSR.UserID).UserStatus > (SimTradeUserStatusEnmu)1)
//                            //{
//                            //    QSR.Code = 10;
//                            //    QSR.Message = "用户已被禁";
//                            //    QSR.DataType = QuanYiServerBaseClass.DataTypeEnum.Order;
//                            //    break;
//                            //}
//                            QSR.Trade.Command = "";
//                            int? brokerid = QSR.Trade.BrokerID;
//                            //if (QSR.Trade.ReceiverId == 0)
//                            //{
//                            //    brokerid = 0;
//                            //    List<BidHistory> AllowedBids = ServerWebSocketHelper.GetBidHistories(QSR.Trade.TsCode);
//                            //    AllowedBids = AllowedBids.Where(x => UserData.Single(y => y.UserID == QSR.UserID).BrokerList.Contains(x.BrokerId)).ToList();
//                            //    AllowedBids = AllowedBids.Where(x => !Trades.Where(y => y.OnHoldVolume > 0 & y.TsCode == QSR.Trade.TsCode & y.OrderType == QSR.Trade.OrderType).GroupBy(z => z.BrokerID).Select(z => z.Key).Contains(x.BrokerId)).ToList();
//                            //    PrismApplication.Current.Dispatcher.Invoke(() =>
//                            //    {
//                            //        AllowedBids = AllowedBids
//                            //            .Where(x => !Trades
//                            //                .Where(y => y.OnHoldVolume > 0 && y.TsCode == QSR.Trade.TsCode && y.OrderType == QSR.Trade.OrderType)
//                            //                .GroupBy(z => z.BrokerID)
//                            //                .Select(z => z.Key)
//                            //                .Contains(x.BrokerId))
//                            //            .ToList();
//                            //    });
//                            //    if (AllowedBids.Count == 0)
//                            //    {
//                            //        List<UserTrade> tmpTrades = null;
//                            //        bool bFindSamePrice = false;
//                            //        PrismApplication.Current.Dispatcher.Invoke(() =>
//                            //        {
//                            //            tmpTrades = Trades.Where(x => x.TsCode == QSR.Trade.TsCode & x.OrderType == QSR.Trade.OrderType).OrderBy(x => x.Price).ToList();

//                            //        });
//                            //        //List<UserTrade> tmpTrades = Trades.Where(x => x.TsCode == QSR.Trade.TsCode & x.OrderType == QSR.Trade.OrderType).OrderBy(x => x.Price).ToList();
//                            //        UserTrade t = null;
//                            //        if (QSR.Trade.OrderType == UserTrade.UserTradeOrderTypeEnum.Bid)
//                            //        {
//                            //            if (QSR.Trade.Price > Trades.Max(x => x.Price))
//                            //            {
//                            //                QSR.Code = 10;
//                            //                QSR.Message = "暂无可用中介";
//                            //                break;
//                            //            }
//                            //            else
//                            //            {
//                            //                t = tmpTrades.FirstOrDefault(x => x.Price == QSR.Trade.Price);
//                            //                if (t == null)
//                            //                {
//                            //                    t = t = tmpTrades.Last();
//                            //                }
//                            //                else
//                            //                {
//                            //                    bFindSamePrice = true;
//                            //                }
//                            //            }
//                            //        }
//                            //        else
//                            //        {
//                            //            if (QSR.Trade.Price < Trades.Min(x => x.Price))
//                            //            {
//                            //                QSR.Code = 10;
//                            //                QSR.Message = "暂无可用中介";
//                            //                break;
//                            //            }
//                            //            else
//                            //            {
//                            //                t = tmpTrades.FirstOrDefault(x => x.Price == QSR.Trade.Price);
//                            //                if (t == null)
//                            //                {
//                            //                    t = t = tmpTrades.First();
//                            //                }
//                            //                else
//                            //                {
//                            //                    bFindSamePrice = true;
//                            //                }
//                            //            }
//                            //        }
//                            //        if (t == null)
//                            //        {
//                            //            QSR.Code = 10;
//                            //            QSR.Message = "暂无可用中介";
//                            //            break;
//                            //        }
//                            //        brokerid = t.BrokerID;
//                            //        string dtDate;
//                            //        if (!bFindSamePrice)
//                            //        {
//                            //            dtDate = t.DeliveryDate.Month.ToString() + "月" + t.DeliveryDate.Day.ToString() + "日";
//                            //            QSR.Trade.Command = $"T{t.DailyID:D3} {t.TsCode} {t.Price} {dtDate}+0 {t.Volume / 1000}k 改 ";
//                            //            if (QSR.Trade.Price != t.Price)
//                            //            {
//                            //                QSR.Trade.Command += $"{QSR.Trade.Price} ";
//                            //            }
//                            //            if (QSR.Trade.DeliveryDate != t.DeliveryDate)
//                            //            {
//                            //                dtDate = QSR.Trade.DeliveryDate.Month.ToString() + "月" + QSR.Trade.DeliveryDate.Day.ToString() + "日";
//                            //                QSR.Trade.Command += $"{dtDate} ";
//                            //            }
//                            //            if (QSR.Trade.Volume != t.Volume)
//                            //            {
//                            //                QSR.Trade.Command += $"{QSR.Trade.Volume / 1000}k ";
//                            //            }
//                            //        }
//                            //        _userHelper.CancelUserTrade(t.UserTradeID, serverWebSocketFromClient.GetUserToken(t.UserID), out msg);
//                            //        QSR.Message = msg;
//                            //    }
//                            //    else
//                            //    {
//                            //        switch (QSR.Trade.OrderType)
//                            //        {
//                            //            case UserTrade.UserTradeOrderTypeEnum.Bid:
//                            //                AllowedBids = AllowedBids.Where(x => x.BidType == BidHistory.enumBidType.Bid).OrderByDescending(x => x.Price).ThenBy(x => x.Volume).ToList();
//                            //                if (AllowedBids.Count > 0)
//                            //                {
//                            //                    brokerid = AllowedBids.First().BrokerId;
//                            //                    foreach (var b in AllowedBids)
//                            //                    {
//                            //                        if (QSR.Trade.Price <= b.Price)
//                            //                        {
//                            //                            brokerid = b.BrokerId;
//                            //                            break;
//                            //                        }
//                            //                    }
//                            //                }
//                            //                else
//                            //                {
//                            //                    brokerid = UserData.Single(y => y.UserID == QSR.UserID).BrokerList.First();
//                            //                }
//                            //                break;
//                            //            case UserTrade.UserTradeOrderTypeEnum.Ofr:
//                            //                AllowedBids = AllowedBids.Where(x => x.BidType == BidHistory.enumBidType.Ofr).OrderBy(x => x.Price).ThenBy(x => x.Volume).ToList();
//                            //                if (AllowedBids.Count > 0)
//                            //                {
//                            //                    brokerid = AllowedBids.First().BrokerId;
//                            //                    foreach (var b in AllowedBids)
//                            //                    {
//                            //                        if (QSR.Trade.Price >= b.Price)
//                            //                        {
//                            //                            brokerid = b.BrokerId;
//                            //                            break;
//                            //                        }
//                            //                    }
//                            //                }
//                            //                else
//                            //                {
//                            //                    brokerid = UserData.Single(y => y.UserID == QSR.UserID).BrokerList.First();
//                            //                }
//                            //                break;
//                            //            default:
//                            //                break;
//                            //        }
//                            //    }
//                            //}
//                            //else
//                            //{
//                            //    chat = Receivers.Single(x => x.Id == QSR.Trade.ReceiverId);
//                            //    tmpTrade = Trades.FirstOrDefault(x => x.TsCode == QSR.Trade.TsCode & x.OrderType == QSR.Trade.OrderType & x.OnHoldVolume > 0 & x.BrokerID == chat.Brokerid);
//                            //    if (tmpTrade != null)
//                            //    {
//                            //        if (tmpTrade.Price != QSR.Trade.Price)
//                            //        {
//                            //            brokerid = 0;
//                            //            List<BidHistory> AllowedBids = ServerWebSocketHelper.GetBidHistories(QSR.Trade.TsCode);
//                            //            AllowedBids = AllowedBids.Where(x => UserData.Single(y => y.UserID == QSR.UserID).BrokerList.Contains(x.BrokerId)).ToList();
//                            //            AllowedBids = AllowedBids.Where(x => !Trades.Where(y => y.OnHoldVolume > 0 & y.TsCode == QSR.Trade.TsCode & y.OrderType == QSR.Trade.OrderType).GroupBy(z => z.BrokerID).Select(z => z.Key).Contains(x.BrokerId)).ToList();
//                            //            if (AllowedBids.Count == 0)
//                            //            {
//                            //                bool bFindSamePrice = false;
//                            //                List<UserTrade> tmpTrades = Trades.Where(x => x.TsCode == QSR.Trade.TsCode & x.OrderType == QSR.Trade.OrderType).OrderBy(x => x.Price).ToList();
//                            //                UserTrade t = null;
//                            //                if (QSR.Trade.OrderType == UserTrade.UserTradeOrderTypeEnum.Bid)
//                            //                {
//                            //                    if (QSR.Trade.Price > Trades.Max(x => x.Price))
//                            //                    {
//                            //                        QSR.Code = 10;
//                            //                        QSR.Message = "暂无可用中介";
//                            //                        break;
//                            //                    }
//                            //                    else
//                            //                    {
//                            //                        t = tmpTrades.FirstOrDefault(x => x.Price == QSR.Trade.Price);
//                            //                        if (t == null)
//                            //                        {
//                            //                            t = t = tmpTrades.Last();
//                            //                        }
//                            //                        else
//                            //                        {
//                            //                            bFindSamePrice = true;
//                            //                        }
//                            //                    }
//                            //                }
//                            //                else
//                            //                {
//                            //                    if (QSR.Trade.Price < Trades.Min(x => x.Price))
//                            //                    {
//                            //                        QSR.Code = 10;
//                            //                        QSR.Message = "暂无可用中介";
//                            //                        break;
//                            //                    }
//                            //                    else
//                            //                    {
//                            //                        t = tmpTrades.FirstOrDefault(x => x.Price == QSR.Trade.Price);
//                            //                        if (t == null)
//                            //                        {
//                            //                            t = t = tmpTrades.First();
//                            //                        }
//                            //                        else
//                            //                        {
//                            //                            bFindSamePrice = true;
//                            //                        }
//                            //                    }
//                            //                }
//                            //                if (t == null)
//                            //                {
//                            //                    QSR.Code = 10;
//                            //                    QSR.Message = "暂无可用中介";
//                            //                    break;
//                            //                }
//                            //                brokerid = t.BrokerID;
//                            //                string dtDate = QSR.Trade.DeliveryDate.Month.ToString() + "月" + QSR.Trade.DeliveryDate.Day.ToString() + "日";
//                            //                if (!bFindSamePrice)
//                            //                {
//                            //                    QSR.Trade.Command = $"ref T{t.DailyID:D3} {t.TsCode} {t.Price} {t.Volume / 1000}k 若撤单成功则 __TID__ {QSR.Trade.DealType} {QSR.Trade.TsCode.Replace(".IB", "")} {QSR.Trade.Price} {dtDate}+0 {QSR.Trade.Volume / 1000}k";
//                            //                }
//                            //                _userHelper.CancelUserTrade(t.UserTradeID, serverWebSocketFromClient.GetUserToken(t.UserID), out msg);
//                            //                QSR.Message = msg;
//                            //            }
//                            //        }
//                            //        else
//                            //        {
//                            //            brokerid = (int)chat.Brokerid;
//                            //        }
//                            //    }
//                            //    else
//                            //    {
//                            //        brokerid = (int)chat.Brokerid;
//                            //    }
//                            //}
//                            chat = Receivers.FirstOrDefault(x => x.Brokerid == brokerid);
//                            if (chat == null)
//                            {
//                                //QSR.Message = "未找到可用中介";
//                                //QSR.Code = 6;
//                                //serverWebSocketFromClient.SendResponseToClient(QSR);
//                                //return;
//                                //没找到对应中介
//                            }

//                            if (brokerid == -1)
//                            {
//                                brokerid = null;
//                                QSR.Trade.ChatID = null;
//                                QSR.Trade.Broker = null;


//                                QSR.Trade.BrokerID = brokerid;
//                                QSR.Trade.ReceiverId = null;
//                                //chat.OrderInProgress = true;
//                                QSR.Trade.Time = DateTime.Now;
//                                QSR.Trade.UserName = UserData.Single(x => x.UserID == QSR.UserID).UserName;
//                            }
//                            else
//                            {
//                                QSR.Trade.ChatID = chat.ChatId;
//                                QSR.Trade.Broker = chat.Company;


//                                QSR.Trade.BrokerID = brokerid;

//                                QSR.Trade.ReceiverId = chat.Id;
//                                //chat.OrderInProgress = true;

//                                QSR.Trade.Time = DateTime.Now;


//                                QSR.Trade.UserName = UserData.Single(x => x.UserID == QSR.UserID).UserName;
//                            }



//                            string changePriceIds = string.Empty;
//                            int realBrokerId = 0;
//                            string realOrderMsg = string.Empty;
//                            result = _userHelper.AddUserTrade(QSR.Trade, QSR.Token, out UserTradeID, out msg, out ActualVolume, ref changePriceIds, out realBrokerId, out realOrderMsg);
//                            switch (result)
//                            {
//                                case 0:
//                                    //_dailyData.BondHelperSysLog(QSR.UserID, "Lily下单成功," + msg, UserTradeID);
//                                    QSR.Trade.BrokerID = realBrokerId;
//                                    QSR.Trade.OnHoldVolume = ActualVolume;
//                                    QSR.Trade.Volume = ActualVolume;
//                                    QSR.Message = msg;
//                                    break;
//                                case 1:
//                                    QSR.Message = msg;
//                                    QSR.Code = 6;
//                                    QSR.DataType = QuanYiServerBaseClass.DataTypeEnum.Order;
//                                    //_dailyData.BondHelperSysLog(QSR.UserID, "Lily下单失败, " + msg, 0);
//                                    break;
//                                case 2:
//                                    QSR.Code = 4;
//                                    QSR.Message = msg;
//                                    //_dailyData.BondHelperSysLog(QSR.UserID, "Lily下单成功," + msg, UserTradeID);
//                                    QSR.Trade.Volume = ActualVolume;
//                                    QSR.Trade.OnHoldVolume = ActualVolume;
//                                    break;

//                                case 3:
//                                    QSR.Code = 11;
//                                    QSR.Message = "发起重定向改价操作" + msg;
//                                    //_dailyData.BondHelperSysLog(QSR.UserID, "Lily发起重定向改价操作," + msg, UserTradeID);
//                                    QSR.Trade.Volume = ActualVolume;
//                                    QSR.Trade.OnHoldVolume = ActualVolume;
//                                    QSR.ChangePriceIds = changePriceIds;
//                                    break;
//                                default:
//                                    break;
//                            }
//                            OrderLog += "下单相关：" + QSR.Trade.Command + "回应：" + QSR.Message + "\r\n";
//                            QSR.Trade.UserTradeID = UserTradeID;

//                            if (QSR.Code != 6 && QSR.Code != 11)
//                            {
//                                CurrentDailyID++;
//                                QSR.Trade.DailyID = CurrentDailyID;

//                                if (QSR.Trade.BrokerID == null && !string.IsNullOrEmpty(realOrderMsg))//对于自动特殊赋值一下
//                                {
//                                    JObject obj = JObject.Parse(realOrderMsg);
//                                    int userTradeId = (int)obj["userTradeId"];
//                                    string tradeNum = (string)obj["tradeNum"];
//                                    string relativeNum = (string)obj["relativeNum"];
//                                    string sourceNum = (string)obj["sourceNum"];
//                                    int isYouxian = (int)obj["isYouxian"];
//                                    int youxianLevel = (int)obj["youxianLevel"];
//                                    string direction = (string)obj["direction"];
//                                    string tscode = (string)obj["tscode"];
//                                    int volume = (int)obj["volume"];
//                                    string finishVolume = (string)obj["finishVolume"];
//                                    int restVolume = (int)obj["restVolume"];
//                                    decimal price = (decimal)obj["price"];
//                                    double worstPrice = (double)obj["worstPrice"];
//                                    DateTime deliveryTime = (DateTime)obj["deliveryTime"];
//                                    string deliverySpeed = (string)obj["deliverySpeed"];
//                                    int createBy = (int)obj["createBy"];
//                                    DateTime createTime = (DateTime)obj["createTime"];
//                                    int? updateBy = (int?)obj["updateBy"];
//                                    DateTime? updateTime = (DateTime?)obj["updateTime"];
//                                    string remark = (string)obj["remark"];
//                                    int userId = (int)obj["userId"];
//                                    int status = (int)obj["status"];
//                                    bool forward = (bool)obj["forward"];
//                                    int parentId = (int)obj["parentId"];
//                                    string orderType = (string)obj["orderType"];
//                                    string qiangpingId = (string)obj["qiangpingId"];
//                                    int brokerId1 = (int)obj["brokerId"];
//                                    string channelId = (string)obj["channelId"];
//                                    int version = (int)obj["version"];
//                                    string gaijiaTradeIds = (string)obj["gaijiaTradeIds"];
//                                    string message = (string)obj["message"];
//                                    string target = (string)obj["target"];
//                                    QSR.Trade.ChannelID = channelId;
//                                    QSR.Trade.BrokerID = brokerId1;
//                                    QSR.Trade.UserTradeID = createBy;
//                                    QSR.Trade.Volume = volume;
//                                    QSR.Trade.OnHoldVolume = restVolume;
//                                    QSR.Trade.Price = price;
//                                    QSR.Trade.Status = status;
//                                    QSR.Trade.UserID = userId;
//                                    QSR.Trade.Time = createTime;
//                                    QSR.Trade.TsCode = tscode;
//                                    QSR.Trade.Broker = Receivers.Where(o => o.Brokerid == brokerId1).FirstOrDefault().Company;
//                                    QSR.Trade.ChatID = Receivers.Where(o => o.Brokerid == brokerId1).FirstOrDefault().ChatId;
//                                    QSR.Trade.ReceiverId = Receivers.Where(o => o.Brokerid == brokerId1).FirstOrDefault().Id;
//                                }
//                                //if (!_dailyData.AddUserTrade(QSR.Trade, out msg))
//                                //{
//                                //    QSR.Message = msg;
//                                //    QSR.Code = 6;
//                                //    //MessageBox.Show("询价单已发送，但创建询价单失败", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
//                                //    _dailyData.BondHelperSysLog(QSR.UserID, "BondHelper下单失败" + msg, UserTradeID);
//                                //}
//                                //else
//                                //{
//                                //    _dailyData.BondHelperSysLog(QSR.UserID, "BondHelper下单成功" + msg, UserTradeID);
//                                //}
//                                QSR.Trade.StatusText = "已接收";
//                                PrismApplication.Current.Dispatcher.Invoke(() =>
//                                {
//                                    Trades.Insert(0, QSR.Trade); // 在 UI 线程上插入元素到 Trades 集合
//                                });
//                                if (QSR.Trade.Command == "")
//                                {
//                                    string dtDate = QSR.Trade.DeliveryDate.Month.ToString() + "月" + QSR.Trade.DeliveryDate.Day.ToString() + "日";
//                                    QSR.Trade.Command = $"T{QSR.Trade.DailyID:D3} {QSR.Trade.DealType} {QSR.Trade.TsCode.Replace(".IB", "")} {QSR.Trade.Price} {dtDate}+0 {QSR.Trade.Volume / 1000}k";
//                                }
//                                else
//                                {
//                                    QSR.Trade.Command = QSR.Trade.Command.Replace("__TID__", $"T{QSR.Trade.DailyID.ToString("D3")}");
//                                }
//                            }
//                            if (QSR.Code == 0 || QSR.Code == 2)
//                            {
//                                SendMessage(QSR, 1);
//                                //询价单发送给lily
//                                if (QSR != null)
//                                {
//                                    ChatMessage chatMessage = new ChatMessage() { BrokerId = QSR.Trade.BrokerID, ChannelId = QSR.Trade.ChannelID, ChatMessageInfo = QSR.Message, TradeId = QSR.Trade.UserTradeID, ChatId = QSR.Trade.UserID };
//                                    this.SaveMessageToLily(0, chatMessage);
//                                }

//                            }
//                        }
//                        catch (Exception ex)
//                        {
//                            AppLog.WriteError(ex.Message + "QuanyiServer" + "Socket_QuanYiClientMessageEvent", ex.StackTrace);
//                            //_dailyData.BondHelperSysLog(QSR.UserID, "创建订单，" + ex.Message, QSR.Trade.UserTradeID);
//                            QSR.Code = 7;
//                            QSR.Message = ex.Message;
//                            //serverWebSocketFromClient.SendResponseToClient(QSR);
//                        }
//                        break;
//                    case QuanYiServerBaseClass.DataTypeEnum.ChangePrice:



//                        //tmpTrade = Trades.SingleOrDefault(x => x.UserTradeID == QSR.Trade.UserTradeID);
//                        //if (tmpTrade == null)
//                        //{
//                        //    //_dailyData.BondHelperSysLog(QSR.UserID, "Lily改价失败 - 无法找到该笔订单", tmpTrade.UserTradeID);
//                        //    QSR.Code = 2;
//                        //    QSR.Message = "无法找到该笔订单";
//                        //    break;
//                        //}
//                        //if (tmpTrade.Status != 0 & tmpTrade.Status != 1 & tmpTrade.Status != 4)
//                        //{
//                        //    _dailyData.BondHelperSysLog(QSR.UserID, "Lily改价失败 - 该单已成交", tmpTrade.UserTradeID);
//                        //    QSR.Code = 2;
//                        //    QSR.Message = "该单已成交，无法改价";
//                        //}
//                        //else
//                        //{
//                        //    string dtDate = tmpTrade.DeliveryDate.Month.ToString() + "月" + tmpTrade.DeliveryDate.Day.ToString() + "日";
//                        //    QSR.Trade.Command = $"T{QSR.Trade.DailyID:D3} {QSR.Trade.TsCode} {tmpTrade.Price} {dtDate}+0 {QSR.Trade.Volume / 1000}k 改 ";
//                        //    if (QSR.Trade.Price != tmpTrade.Price)
//                        //    {
//                        //        QSR.Trade.Command += $"{QSR.Trade.Price} ";
//                        //    }
//                        //    if (QSR.Trade.DeliveryDate != tmpTrade.DeliveryDate)
//                        //    {
//                        //        dtDate = QSR.Trade.DeliveryDate.Month.ToString() + "月" + QSR.Trade.DeliveryDate.Day.ToString() + "日";
//                        //        QSR.Trade.Command += $"{dtDate} ";
//                        //    }
//                        //    if (QSR.Trade.Volume != tmpTrade.Volume)
//                        //    {
//                        //        QSR.Trade.Command += $"{QSR.Trade.Volume / 1000}k ";
//                        //    }
//                        string returnMsg = string.Empty;
//                        if (!_userHelper.ModifyUserTrade(QSR.Trade, QSR.Token, out msg, out returnMsg))
//                        {
//                            //_dailyData.BondHelperSysLog(QSR.UserID, "Lily改价失败", tmpTrade.UserTradeID);
//                            QSR.Code = 2;
//                            QSR.Message = "Lily改价失败" + returnMsg;
//                            break;
//                        }
//                        else
//                        {
//                            QSR.Code = 0;
//                            QSR.Message = msg;
//                            SendMessage(QSR, 1);
//                            //改价存到lily
//                            if (QSR != null)
//                            {
//                                ChatMessage chatMessage = new ChatMessage() { BrokerId = QSR.Trade.BrokerID, ChannelId = QSR.Trade.ChannelID, ChatMessageInfo = msg, TradeId = QSR.Trade.UserTradeID, ChatId = int.Parse(QSR.Trade.ChatID) };
//                                this.SaveMessageToLily(0, chatMessage);
//                            }
//                        }
//                        OrderLog += "改价相关：" + msg + "回应：" + QSR.Message + "\r\n";

//                        //QSR.Code = 0;
//                        //QSR.Message = "改价指令已发送";

//                        break;
//                    case QuanYiServerBaseClass.DataTypeEnum.ChangePriceConfirm:
//                        tmpTrade = Trades.SingleOrDefault(x => x.UserTradeID == QSR.Trade.UserTradeID);
//                        if (tmpTrade == null)
//                        {
//                            //_dailyData.BondHelperSysLog(QSR.UserID, "Lily改价失败 - 无法找到该笔订单", tmpTrade.UserTradeID);
//                            QSR.Code = 2;
//                            QSR.Message = "无法找到该笔订单";
//                            break;
//                        }
//                        if (tmpTrade.Status != 0 & tmpTrade.Status != 1 & tmpTrade.Status != 4)
//                        {
//                            QSR.Code = 2;
//                            QSR.Message = "该单已成交，无法改价";
//                        }
//                        else
//                        {
//                            //string returnMsg = string.Empty;
//                            if (!_userHelper.ModifyUserTrade(QSR.Trade, QSR.Token, out msg, out returnMsg))
//                            {
//                                //_dailyData.BondHelperSysLog(QSR.UserID, "Lily改价失败", tmpTrade.UserTradeID);
//                                QSR.Code = 2;
//                                QSR.Message = returnMsg;
//                                break;
//                            }
//                            if (!_dailyData.UpdateUserTrade(QSR.Trade))
//                            {
//                                QSR.Code = 2;
//                                QSR.Message = "改价失败";
//                                break;
//                            }

//                            //if (!_dailyData.UpdateUserTrade(tmpTrade))
//                            //{
//                            //    QSR.Code = 2;
//                            //    QSR.Message = "修改BondHelper询价单失败";
//                            //    AppLog.WriteError($"改价：修改BondHelper询价单失败{QSR.Trade.Command},{QSR.Trade.Target}" + QSR.Trade.UserTradeID.ToString());
//                            //    _dailyData.BondHelperSysLog(QSR.UserID, "修改BondHelper询价单失败", tmpTrade.UserTradeID);
//                            //    break;
//                            //}
//                            //_dailyData.BondHelperSysLog(QSR.UserID, "改价成功", tmpTrade.UserTradeID);
//                            tmpTrade.Price = QSR.Trade.Price;
//                            QSR.Code = 0;
//                            QSR.Message = "订单已更新";
//                        }
//                        break;
//                    case QuanYiServerBaseClass.DataTypeEnum.Withdraw:
//                        //tmpTrade = Trades.SingleOrDefault(x => x.UserTradeID == QSR.Trade.UserTradeID);
//                        //if (tmpTrade == null)
//                        //{
//                        //    _dailyData.BondHelperSysLog(QSR.UserID, "撤单失败 - 无法找到该笔订单", QSR.Trade.UserTradeID);
//                        //    QSR.Code = 3;
//                        //    QSR.Message = "无法找到该笔订单";
//                        //    break;
//                        //}
//                        //if (tmpTrade.Status != 0 & tmpTrade.Status != 1 & tmpTrade.Status != 4)
//                        //{
//                        //    QSR.Code = 2;
//                        //    QSR.Message = "该单已成交，无法改价";
//                        //}
//                        //else
//                        //{
//                        //    string returnMsg1 = string.Empty;
//                        //    QSR.Trade.Command = $"ref T{QSR.Trade.DailyID:D3} {QSR.Trade.TsCode} {QSR.Trade.Price} {QSR.Trade.OnHoldVolume / 1000}k";
//                        string returnMsg1 = string.Empty;
//                        if (!_userHelper.CancelUserTrade(QSR.Trade.UserTradeID, QSR.Token, out msg, out returnMsg1))
//                        {
//                            //_dailyData.BondHelperSysLog(QSR.UserID, "Lily撤单失败",QSR.Trade.UserTradeID);
//                            QSR.Code = 3;
//                            QSR.Message = "Lily撤单失败" + msg;
//                            break;
//                        }
//                        else
//                        {
//                            //_dailyData.BondHelperSysLog(QSR.UserID, "撤单成功", QSR.Trade.UserTradeID);
//                            QSR.Code = 0;
//                            QSR.Message = msg;
//                            QSR.Trade.Status = 5;
//                            QSR.Trade.StatusText = "已撤单";
//                            QSR.Trade.Status = 5;
//                            QSR.Trade.StatusText = "已撤单";

//                            SendMessage(QSR, 1);

//                            //撤单存到lily
//                            if (QSR != null)
//                            {
//                                ChatMessage chatMessage = new ChatMessage() { BrokerId = QSR.Trade.BrokerID, ChannelId = QSR.Trade.ChannelID, ChatMessageInfo = msg, TradeId = QSR.Trade.UserTradeID, ChatId = QSR.Trade.UserID };
//                                this.SaveMessageToLily(0, chatMessage);
//                            }


//                        }
//                        OrderLog += "撤单相关：" + QSR.Trade.Command + "回应：" + QSR.Message + "\r\n";

//                        break;
//                    //withdrawed去掉就行，2024/06/26
//                    //case QuanYiServerBaseClass.DataTypeEnum.Withdrawed:
//                    //    tmpTrade = Trades.SingleOrDefault(x => x.UserTradeID == QSR.Trade.UserTradeID);
//                    //    if (tmpTrade == null)
//                    //    {
//                    //        _dailyData.BondHelperSysLog(QSR.UserID, "撤单失败 - 无法找到该笔订单", tmpTrade.UserTradeID);
//                    //        QSR.Code = 3;
//                    //        QSR.Message = "无法找到该笔订单";
//                    //        break;
//                    //    }
//                    //    if (tmpTrade.Status != 0 & tmpTrade.Status != 1 & tmpTrade.Status != 4)
//                    //    {
//                    //        QSR.Code = 2;
//                    //        QSR.Message = "该单已成交，无法改价";
//                    //    }
//                    //    else
//                    //    {
//                    //        if (!_userHelper.CancelUserTrade(QSR.Trade.UserTradeID, QSR.Token, out msg))
//                    //        {
//                    //            _dailyData.BondHelperSysLog(QSR.UserID, "Lily撤单失败", tmpTrade.UserTradeID);
//                    //            QSR.Code = 3;
//                    //            QSR.Message = "Lily撤单失败";
//                    //            break;
//                    //        }
//                    //        else
//                    //        {
//                    //            _dailyData.BondHelperSysLog(QSR.UserID, "撤单成功", tmpTrade.UserTradeID);
//                    //            QSR.Code = 0;
//                    //            QSR.Message = "撤单成功";
//                    //            QSR.Trade.Status = 5;
//                    //            QSR.Trade.StatusText = "已撤单";
//                    //            tmpTrade.Status = 5;
//                    //            tmpTrade.StatusText = "已撤单";
//                    //        }
//                    //    }
//                    //    break;
//                    //case QuanYiServerBaseClass.DataTypeEnum.BackdatedOrder:
//                    //    result = userhepler.AddUserTrade(QSR.Trade, QSR.Token, out UserTradeID, out msg, out ActualVolume);
//                    //    switch (result)
//                    //    {
//                    //        case 0:
//                    //            daily.BondHelperSysLog(QSR.UserID, "Lily下单成功," + msg, UserTradeID);
//                    //            QSR.Trade.Volume = ActualVolume;
//                    //            break;
//                    //        case 1:
//                    //            QSR.Message = msg;
//                    //            QSR.Code = 6;
//                    //            daily.BondHelperSysLog(QSR.UserID, "Lily下单失败, " + msg, 0);
//                    //            break;
//                    //        case 2:
//                    //            QSR.Message = msg;
//                    //            QSR.Code = 4;
//                    //            QSR.Trade.Volume = ActualVolume;
//                    //            daily.BondHelperSysLog(QSR.UserID, "Lily下单成功," + msg, UserTradeID);
//                    //            break;
//                    //        default:
//                    //            break;
//                    //    }
//                    //    QSR.Trade.UserTradeID = UserTradeID;

//                    //    break;
//                    //case QuanYiServerBaseClass.DataTypeEnum.Trade:
//                    //    tmpTrade = Trades.SingleOrDefault(x => x.UserTradeID == QSR.Trade.UserTradeID);
//                    //    if (tmpTrade == null)
//                    //    {
//                    //        daily.BondHelperSysLog(QSR.UserID, "撤单失败 - 无法找到该笔订单", tmpTrade.UserTradeID);
//                    //        QSR.Code = 3;
//                    //        QSR.Message = "无法找到该笔订单";
//                    //        break;
//                    //    }
//                    //    tmpTrade.OnHoldVolume = QSR.Trade.OnHoldVolume;
//                    //    tmpTrade.Status = QSR.Trade.Status;
//                    //    tmpTrade.StatusText = QSR.Trade.StatusText;
//                    //    daily.BondHelperSysLog(QSR.UserID, "Lily成交,", tmpTrade.UserTradeID);
//                    //    break;
//                    case QuanYiServerBaseClass.DataTypeEnum.PingCang:
//                        if (QSR.Trade.BrokerID == -1)
//                        {
//                            QSR.Trade.BrokerID = null;
//                            QSR.Trade.ChatID = null;
//                            QSR.Trade.Broker = null;


//                            QSR.Trade.ReceiverId = null;
//                            //chat.OrderInProgress = true;
//                            QSR.Trade.Time = DateTime.Now;
//                            QSR.Trade.UserName = UserData.Single(x => x.UserID == QSR.UserID).UserName;
//                        }
//                        int brokerId = 0;
//                        int pingCangRes = _userHelper.PingCangUserTrade(QSR.Trade, QSR.Token, out msg, out brokerId);

//                        switch (pingCangRes)
//                        {
//                            case 0:
//                                QSR.Code = 0;
//                                QSR.Trade.BrokerID = brokerId;
//                                QSR.Trade.ChannelID = Receivers.Where(o => o.Brokerid == brokerId).FirstOrDefault().ChannelId;
//                                QSR.Message = msg;
//                                break;

//                            case 3:
//                                QSR.Code = 11;
//                                QSR.Message = "发起重定向改价操作" + msg;
//                                break;
//                            default:
//                                QSR.Message = msg;
//                                break;
//                        }
//                        if (QSR.Code == 0)
//                        {
//                            SendMessage(QSR, 1);
//                            //撤单存到lily
//                            if (QSR != null)
//                            {
//                                ChatMessage chatMessage = new ChatMessage() { BrokerId = QSR.Trade.BrokerID, ChannelId = QSR.Trade.ChannelID, ChatMessageInfo = msg, TradeId = QSR.Trade.UserTradeID, ChatId = QSR.Trade.UserID };
//                                this.SaveMessageToLily(0, chatMessage);
//                            }
//                        }


//                        break;


//                    //case QuanYiServerBaseClass.DataTypeEnum.InitChatMessage:
//                    //    foreach (var r in Receivers)
//                    //    {
//                    //        lock (r)
//                    //        {
//                    //            QuanYiOrderServerResponseClass msgQsr = new QuanYiOrderServerResponseClass();
//                    //            msgQsr.UserID = QSR.UserID;
//                    //            msgQsr.SessionID = QSR.SessionID;
//                    //            msgQsr.BrokerID = r.BrokerID;
//                    //            msgQsr.DataType = QuanYiServerBaseClass.DataTypeEnum.ChatMessage;
//                    //            msgQsr.ChatImage = r.ChatMessage;
//                    //            serverWebSocketFromClient.SendResponseToClient(msgQsr);
//                    //        }
//                    //    }
//                    //    break;
//                    case QuanYiServerBaseClass.DataTypeEnum.ChatMessage:
//                        SendMessage(QSR, 0); // 0代表普通消息，1代表下单的消息

//                        //快捷回复存到lily,先不存！
//                        //if (QSR != null)
//                        //{

//                        //    ChatMessage chatMessage = new ChatMessage() { BrokerId = QSR.BrokerID, ChatMessageInfo = QSR.ChatMessage, ChatId = QSR.UserID };
//                        //    this.SaveMessageToLily(0, chatMessage);
//                        //}
//                        break;
//                    //ChatReceiver r1 = Receivers.Single(x => x.BrokerID == QSR.BrokerID);
//                    //if (r1 != null)
//                    //{
//                    //    UserTrade t = new UserTrade();
//                    //    t.Broker = r1.Broker;
//                    //    t.ChatID = r1.ChatID;
//                    //    t.Command = QSR.Message;
//                    //    t.ReceiverId = r1.id;
//                    //    SendMessage(t);
//                    //}
//                    //break;
//                    //case QuanYiServerBaseClass.DataTypeEnum.Deal:
//                    //    if (serverWebSocketFromClient.UserTradeDeal(QSR.Trade, out msg))
//                    //    {
//                    //        QSR.Code = 0;
//                    //    }
//                    //    else
//                    //    {
//                    //        QSR.Code = 1;

//                    //    }
//                    //    QSR.Message = msg;
//                    //    break;
//                    //default:
//                    //    break;
//                    case QuanYiServerBaseClass.DataTypeEnum.RequestReview:
//                        bool res = _dailyData.AddRequestReview(QSR);
//                        if (res)
//                        {
//                            AppLog.WriteInfo("插入一条新的复核" + QSR.RequestReviewMessage);
//                        }
//                        else
//                        {
//                            AppLog.WriteError("插入一条新的复核失败" + QSR.RequestReviewMessage);
//                        }
//                        break;
//                    default:
//                        break;
//                }

//                this.serverWebSocketFromClient?.SendResponseToClient(QSR);
//                this.serverWebSocketFromAdmin?.SendMessageToAdmins(QSR);

//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError(ex.Message + "QuanyiServer" + "Socket_QuanYiClientMessageEvent" + ex.StackTrace);
//                //_dailyData.BondHelperSysLog(QSR.UserID, "客户端消息，" + ex.Message, QSR.Trade == null ? 0 : QSR.Trade.UserTradeID);
//                QSR.Code = 7;
//                QSR.Message = ex.Message;
//                //serverWebSocketFromClient.SendResponseToClient(QSR);
//            }



//        }
//        #endregion

//        #region 服务端——对接管理端服务
//        public void StartAdminServerService()
//        {
//            serverWebSocketFromAdmin = new ServerWebSocketHelper(_dailyData);
//            serverWebSocketFromAdmin.AdminMessageEvent += ServerWebSocketFromAdmin_AdminMessageEvent;
//            serverWebSocketFromAdmin.QuanYiOrderServerMessageEvent += Websocket_QuanYiServerMessageEvent;
//            serverWebSocketFromAdmin.adminWebSocketStart();
//        }


//        /// <summary>
//        /// 收到管理端发给的服务端消息
//        /// </summary>
//        /// <param name="message"></param>
//        /// <exception cref="NotImplementedException"></exception>
//        private void ServerWebSocketFromAdmin_AdminMessageEvent(string message)
//        {
//            Growl.SuccessGlobal(message);
//        }
//        #endregion





//        #region 辅助方法
//        private string GetGreeting()
//        {
//            var hour = DateTime.Now.Hour;
//            if (hour >= 6 && hour < 12)
//            {
//                return "早上好，";
//            }
//            else if (hour >= 12 && hour < 18)
//            {
//                return "中午好，";
//            }
//            else
//            {
//                return "晚上好，";
//            }
//        }

//        private void Greet()
//        {
//            var greeting = GetGreeting();
//            _eventAggregator.GetEvent<MessageEvent>().Publish(new MessageModel()
//            {
//                Filter = "1",
//                Message = "登录成功。" + greeting + LoginViewModel.StaticUserName
//            });
//        }

//        public void RefreshReceivers()
//        {
//            Receivers = _dailyData.GetChatReceivers();
//        }


//        /// <summary>
//        /// 核心方法，找到窗口然后发送
//        /// </summary>
//        /// <param name="order"></param>
//        private void SendMessage(UserTrade order)
//        {

//            IntPtr window = FindWindow(null, order.ChatID.Trim());
//            //IntPtr TextWindows = IntPtr.Zero;
//            //var prc = Process.GetProcessesByName("WeChat.exe");
//            if (window != IntPtr.Zero)
//            {
//                lock (lockObject)
//                {
//                    ShowWindow(window, SW_SHOWNORMAL);
//                    SetForegroundWindow(window);
//                    Thread t = new Thread(() => SendMessageToTarget(order.Command));
//                    t.SetApartmentState(ApartmentState.STA);
//                    t.Start();
//                    t.Join();
//                }
//                //TextWindows = FindTradeWindow(window);
//            }
//            else
//            {
//                AppLog.WriteError("未找到可以交易发送中介的窗口" + order.ToString());
//                return;
//            }

//            //ChatReceiver chat = null;
//            //try
//            //{
//            //    chat = Receivers.Single(x => x.Id == order.ReceiverId);
//            //    if (chat == null)
//            //    {
//            //        _dailyData.BondHelperSysLog(order.UserID, "Cannot find target receiver", order.UserTradeID);
//            //        return;
//            //    }
//            //}
//            //catch (Exception ex)
//            //{
//            //    AppLog.WriteError(ex.Message + "PlaceOrderServer" + "SendMessage" + ex.StackTrace);
//            //    return;
//            //}

//        }


//        public List<Tuple<int, string>> clientSendMessages = new List<Tuple<int, string>>();//发送端缓存？？
//        /// <summary>
//        /// 核心方法，找到窗口然后发送
//        /// </summary>
//        /// <param name="order"></param>
//        //private void SendMessage(QuanYiOrderServerResponseClass qsr)
//        //{
//        //    int brokerId = qsr.BrokerID;
//        //    string chatMsg = qsr.ChatMessage;
//        //    int userId = qsr.UserID;
//        //    string brokerName = Receivers.Single(o => o.Brokerid == brokerId).ChatId;

//        //    IntPtr window = FindWindow(null, brokerName);
//        //    //IntPtr TextWindows = IntPtr.Zero;
//        //    //var prc = Process.GetProcessesByName("WeChat.exe");
//        //    if (window != IntPtr.Zero)
//        //    {
//        //        ShowWindow(window, SW_SHOWNORMAL);
//        //        SetForegroundWindow(window);
//        //        //TextWindows = FindTradeWindow(window);
//        //    }
//        //    else
//        //    {
//        //        AppLog.WriteError("未找到可以交易发送中介的窗口" + brokerName);
//        //        return;
//        //    }

//        //    Task.Delay(100).Wait();
//        //    this.ChatMessageLog += "中介名" + brokerName + "，消息：" + chatMsg + "\r\n";
//        //    Thread t = new Thread(() => SendMessageToTarget(chatMsg));
//        //    t.SetApartmentState(ApartmentState.STA);
//        //    t.Start();
//        //    t.Join();
//        //}
//        //[STAThread]
//        //private void SendMessageToTarget(string msg)
//        //{

//        //    Clipboard.SetText(msg);

//        //    SendKeys.SendWait("^v");
//        //    Task.Delay(10).Wait();

//        //    SendKeys.SendWait("{ENTER}");

//        //}


//        //bug修改，24/07/05 1代表下单，0代表普通
//        private void SendMessage(QuanYiOrderServerResponseClass qsr, int i = 0)
//        {
//            try
//            {
//                lock (lockObject)
//                {
//                    if (i == 0)
//                    {

//                        int brokerId = qsr.BrokerID;
//                        string chatMsg = qsr.ChatMessage;
//                        int userId = qsr.UserID;
//                        string brokerName = Receivers.Single(o => o.Brokerid == brokerId).ChatId;

//                        IntPtr window = FindWindow(null, brokerName);
//                        if (window != IntPtr.Zero)
//                        {


//                            ShowWindow(window, SW_SHOWNORMAL);
//                            SetForegroundWindow(window);


//                            // 将消息添加到字典中
//                            // 将消息文本添加到字典中
//                            AddMessageToDictionary(brokerName, chatMsg);
//                            //SendMessageToTarget(chatMsg);
//                            Thread t = new Thread(() => SendMessageToTarget(chatMsg));
//                            t.SetApartmentState(ApartmentState.STA);
//                            t.Start();
//                            t.Join();
//                        }


//                    }
//                    else
//                    {
//                        UserTrade order = qsr.Trade;
//                        int brokerId = (int)order.BrokerID;
//                        string brokerName = Receivers.Single(o => o.Brokerid == brokerId).ChatId;
//                        IntPtr num = FindWindow(null, brokerName);
//                        string message;
//                        message = qsr?.Message;

//                        if (num != IntPtr.Zero)
//                        {
//                            //lock (lockObject)
//                            //{
//                            ShowWindow(num, SW_SHOWNORMAL);
//                            SetForegroundWindow(num);
//                            string log = "中介名" + brokerName + "，消息：" + message + "\r\n";
//                            AppLog.WriteFatal("记录下单事件" + log);
//                            try
//                            {
//                                // SendMessageToTarget(message);

//                                AddMessageToDictionary(brokerName, message);
//                                //SendMessageToTarget(chatMsg);
//                                Thread t = new Thread(() => SendMessageToTarget(message));
//                                t.SetApartmentState(ApartmentState.STA);
//                                t.Start();
//                                t.Join();
//                                //Thread t = new Thread(() => SendMessageToTarget(message));
//                                //t.SetApartmentState(ApartmentState.STA);
//                                //t.Start();
//                                //t.Join();

//                                //Thread thread = new Thread((ThreadStart)delegate
//                                //{
//                                //    SendMessageToTarget(message);
//                                //});
//                                //thread.SetApartmentState(ApartmentState.STA);
//                                //thread.Start();


//                                //thread.Join();

//                            }
//                            catch (Exception ex)
//                            {
//                                AppLog.WriteError(ex.Message + "PlaceOrderServerSendMessage" + ex.StackTrace, "", true);
//                                return;
//                            }
//                            //}
//                        }
//                        else
//                        {
//                            AppLog.WriteError($"没有找到名为{brokerName}的窗口!");
//                        }
//                    }
//                }
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError($"SendMessage异常，{ex.StackTrace}---{ex.Message}");
//            }
//            finally
//            {
//                Thread.Sleep(10);
//            }
//        }

//        private void AddMessageToDictionary(string brokerName, string message)
//        {
//            // 尝试获取当前字典中是否已有该中介名的消息列表
//            if (SendMessagesDictionary.TryGetValue(brokerName, out var messages))
//            {
//                // 如果已经存在，则添加新的消息到列表中
//                messages.Add(message);
//            }
//            else
//            {
//                // 如果不存在，则创建新的消息列表并添加到字典中
//                messages = new List<string> { message };
//                SendMessagesDictionary.TryAdd(brokerName, messages);
//            }

//            // 可选：日志记录，记录消息添加操作
//            AppLog.WriteInfo($"消息添加到字典：中介名 - {brokerName}，消息 - {message}");
//        }



//        [STAThread]
//        private void SendMessageToTarget(string msg)
//        {
//            try
//            {
//                AppLog.WriteFatal("发送消息" + msg);
//                Clipboard.SetText(msg);


//                SendKeys.SendWait("^v");

//                SendKeys.SendWait("{ENTER}");
//                //SendKeys.SendWait("{ENTER}");
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("SendMessageToTarget异常" + ex.Message + "！" + ex.StackTrace);
//            }


//        }
//        // 声明一个对象作为互斥锁[刷新和发送]
//        private static object lockObject = new object();
//        #endregion

//        #region win32API相关
//        [DllImport("user32.dll")]
//        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

//        [DllImport("user32.dll")]
//        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

//        [DllImport("user32")]
//        static extern int SetForegroundWindow(IntPtr hwnd);

//        private const int SW_SHOWNORMAL = 1;
//        #endregion



//        #region 捕获消息服务
//        List<string> ChatName = new List<string>();
//        //public Dictionary<string, List<ChatMessage>> AllChatDictionary { get; private set; }//字典

//        // 声明 ConcurrentDictionary提高性能
//        private ConcurrentDictionary<string, List<ChatMessage>> AllChatDictionary = new ConcurrentDictionary<string, List<ChatMessage>>();

//        private ConcurrentDictionary<string, List<string>> SendMessagesDictionary = new ConcurrentDictionary<string, List<string>>();

//        private object lock1 = new object();
//        private void StartCaptureMessageService()
//        {
//            try
//            {
//                AllChatDictionary = new ConcurrentDictionary<string, List<ChatMessage>>();
//                Thread t = new Thread(new ThreadStart(CapturePoint));
//                t.IsBackground = true;
//                t.Start();
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("StartCaptureMessageService" + ex.Message + ex.StackTrace);
//            }

//        }

//        private int timerSeconds;

//        public int TimerSeconds
//        {
//            get { return timerSeconds; }
//            set { timerSeconds = value; RaisePropertyChanged(); }
//        }

//        private void ModifyInterval()
//        {
//            if (timer != null && timer.Enabled)
//            {
//                timer.Interval = TimerSeconds * 1000;
//                Growl.SuccessGlobal("定时器间隔修改为：" + TimerSeconds + " 秒");
//            }
//        }

//        public System.Timers.Timer timer { get; set; }

//        #region 同步方法

//        //private void GetChatMessageFromWindow(string chatterName)
//        //{
//        //    try
//        //    {
//        //        IntPtr hWnd = Helper.WindowHelper.FindWindow(null, chatterName);
//        //        if (hWnd == IntPtr.Zero)
//        //        {
//        //            hWnd = Helper.WindowHelper.FindWindow(null, Helper.WindowHelper.getAnotherTitle(chatterName));
//        //            if (hWnd == IntPtr.Zero)
//        //            {
//        //                AppLog.WriteWarn($"未找到{chatterName}的窗口");
//        //                return; // Window not found
//        //            }
//        //        }
//        //        else
//        //        {
//        //            lock (lockObject) // 如果需要保护窗口操作，可以在这里加锁
//        //            {
//        //                ShowWindow(hWnd, SW_SHOWNORMAL);
//        //                SetForegroundWindow(hWnd);
//        //                SendKeys.SendWait("{ENTER}");
//        //            }
//        //            获取窗口左上角坐标
//        //           Point windowPoint = Helper.WindowHelper.GetWindowTopLeftCorner("QiDian", chatterName);

//        //            if (windowPoint.X == 0 && windowPoint.Y == 0 || windowPoint.X.ToString().Contains("-32000"))
//        //            {
//        //                AppLog.WriteInfo($"窗体 {chatterName} 在原点（0,0）");
//        //                return;
//        //                窗体在原点（0,0）
//        //            }
//        //            IntPtr handleQD = Helper.WindowHelper.WindowFromPoint(windowPoint);
//        //            GetMessage(windowPoint, handleQD, chatterName);
//        //        }
//        //    }
//        //    catch (System.Exception ex)
//        //    {
//        //        AppLog.WriteError($"{ex.Message} CheckMsgFromWindow for {chatterName}");
//        //    }
//        //}

//        //private void ReceiveInfo()
//        //{
//        //    lock (lockObject)
//        //    {
//        //        foreach (var chatName in ChatName)
//        //        {
//        //            GetChatMessageFromWindow(chatName);
//        //        }
//        //    }
//        //}

//        private async void TestCatch()
//        {
//            //执行长时间任务
//            //await Task.Delay(2000);
//            //foreach (var chatName in ChatName)
//            //{
//            //    GetChatMessageFromWindowAsync(chatName);
//            //}
//        }


//        //private void CapturePoint()
//        //{
//        //    timer = new System.Timers.Timer();
//        //    timer.Interval = 20000;
//        //    timer.Enabled = true;
//        //    timer.AutoReset = true; // 设置是执行一次（false）还是一直执行(true)
//        //    timer.Elapsed += (o, a) =>
//        //    {
//        //        记录更新开始时间
//        //       DateTime startTime = DateTime.Now;
//        //        AppLog.WriteInfo("更新开始时间：" + startTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//        //        执行长时间任务
//        //        ReceiveInfo();

//        //        记录更新结束时间
//        //       DateTime endTime = DateTime.Now;
//        //        AppLog.WriteInfo("更新结束时间：" + endTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//        //        计算时间差
//        //       TimeSpan elapsedTime = endTime - startTime;
//        //        AppLog.WriteInfo(string.Format("更新花费时间：{0} 毫秒", elapsedTime.TotalMilliseconds));
//        //    };

//        //    timer.Start();
//        //}

//        #endregion



//        #region 异步注释 24/07/17

//        private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();

//        public bool IsCapture = true;
//        private async Task CapturePointAsync(CancellationToken cancellationToken)
//        {
//            while (!cancellationToken.IsCancellationRequested)
//            {
//                // 记录更新开始时间
//                DateTime startTime = DateTime.Now;
//                AppLog.WriteInfo("更新开始时间：" + startTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//                // 执行长时间任务
//                ReceiveInfoAsync();

//                // 记录更新结束时间
//                DateTime endTime = DateTime.Now;
//                AppLog.WriteInfo("更新结束时间：" + endTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//                // 计算时间差
//                TimeSpan elapsedTime = endTime - startTime;
//                AppLog.WriteInfo(string.Format("更新花费时间：{0} 毫秒", elapsedTime.TotalMilliseconds));

//                // 等待15秒
//                await Task.Delay(2000, cancellationToken);
//            }
//        }


//        private Task _captureTask;
//        private bool _isRunning = false;
//        private void StartCapturing()
//        {
//            if (_isRunning)
//            {
//                Console.WriteLine("任务已经在运行中。");
//                return;
//            }

//            // 创建新的 CancellationTokenSource
//            _cancellationTokenSource = new CancellationTokenSource();
//            CancellationToken token = _cancellationTokenSource.Token;

//            _isRunning = true;
//            try
//            {
//                foreach (var chatName in ChatName)
//                {
//                    // 在每次循环中调用方法并传递 CancellationToken
//                    if (token.IsCancellationRequested)
//                    {
//                        Growl.SuccessGlobal("任务已被取消，停止处理后续项");
//                        AppLog.WriteError("任务已被取消，停止处理后续项。");
//                        break; // 取消请求已发出，退出循环
//                    }

//                    GetChatMessageFromWindowAsync(chatName);

//                    // 你可以根据需要在这里添加更多的检查和延迟
//                    // 例如，添加一个短暂的等待，以减少 CPU 使用率
//                    Thread.Sleep(1000);
//                }

//                // 在成功启动任务后，可以使用 Growl 或其他方式提示用户
//                Growl.SuccessGlobal("成功启动扫描QTRADE");
//            }
//            catch (Exception ex)
//            {
//                // 处理异常
//                AppLog.WriteError($"发生错误: {ex.Message}");
//            }
//        }

//        private void StopCapturing()
//        {
//            // 取消任务
//            _cancellationTokenSource.Cancel();

//            // 等待任务完成
//            _cancellationTokenSource.Token.WaitHandle.WaitOne();

//            // 清理 CancellationTokenSource
//            _cancellationTokenSource.Dispose();
//            _cancellationTokenSource = new CancellationTokenSource(); // 重新创建以便未来使用
//        }



//        private void CapturePoint()
//        {
//            //StartCapturing();

//            while (true)
//            {
//                //if(!IsCapture)
//                //{
//                //    break;
//                //}
//                DateTime startTime = DateTime.Now;
//                AppLog.WriteInfo("更新开始时间：" + startTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//                // 执行长时间任务
//                ReceiveInfoAsync();
//                // 记录更新结束时间
//                DateTime endTime = DateTime.Now;
//                AppLog.WriteInfo("更新结束时间：" + endTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//                // 计算时间差
//                TimeSpan elapsedTime = endTime - startTime;
//                AppLog.WriteInfo(string.Format("更新花费时间：{0} 毫秒", elapsedTime.TotalMilliseconds));

//                Thread.Sleep(2000);
//            }
//            //timer = new System.Timers.Timer();
//            //timer.Interval = 15000;
//            //timer.Enabled = true;
//            //timer.AutoReset = true;//设置是执行一次（false）还是一直执行(true)；  
//            //timer.Elapsed += async (o, a) =>
//            //{
//            //    // 记录更新开始时间
//            //    DateTime startTime = DateTime.Now;
//            //    AppLog.WriteInfo("更新开始时间：" + startTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//            //    // 执行长时间任务
//            //    await ReceiveInfoAsync();
//            //    // 记录更新结束时间
//            //    DateTime endTime = DateTime.Now;
//            //    AppLog.WriteInfo("更新结束时间：" + endTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

//            //    // 计算时间差
//            //    TimeSpan elapsedTime = endTime - startTime;
//            //    AppLog.WriteInfo(string.Format("更新花费时间：{0} 毫秒", elapsedTime.TotalMilliseconds));
//            //};

//            //timer.Start();
//        }
//        private SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);


//        private void ReceiveInfoAsync()
//        {
//            //await semaphore.WaitAsync();

//            try
//            {
//                foreach (var chatName in ChatName)
//                {
//                    lock (lockObject)
//                    {
//                        GetChatMessageFromWindowAsync(chatName);
//                    }
//                }
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("ReceiveInfoAsync异常" + ex.Message + ex.StackTrace);
//            }
//            finally
//            {
//                //semaphore.Release();
//            }
//        }


//        private void GetChatMessageFromWindowAsync(string chatterName)
//        {
//            try
//            {

//                IntPtr hWnd = Helper.WindowHelper.FindWindow(null, chatterName);
//                if (hWnd == IntPtr.Zero)
//                {
//                    hWnd = Helper.WindowHelper.FindWindow(null, Helper.WindowHelper.getAnotherTitle(chatterName));
//                    if (hWnd == IntPtr.Zero)
//                    {
//                        //AppLog.WriteWarn($"未找到{chatterName}的窗口");
//                        return; // Window not found
//                    }
//                }
//                else
//                {
//                    lock (lockObject)
//                    {
//                        ShowWindow(hWnd, SW_SHOWNORMAL);
//                        SetForegroundWindow(hWnd);
//                    }

//                    //lock (lockObject) // 如果需要保护窗口操作，可以在这里加锁
//                    //{
//                    //    ShowWindow(hWnd, SW_SHOWNORMAL);
//                    //    SetForegroundWindow(hWnd);
//                    //    SendKeys.SendWait("{ENTER}");
//                    //}
//                    // 异步获取窗口左上角坐标
//                    Point windowPoint = Helper.WindowHelper.GetWindowTopLeftCorner("QiDian", chatterName);

//                    if (windowPoint.X == 0 && windowPoint.Y == 0 || windowPoint.X.ToString().Contains("-32000"))
//                    {
//                        AppLog.WriteInfo($"窗体 {chatterName} 在原点（0,0）");
//                        return;
//                        // 窗体在原点（0,0）
//                    }
//                    IntPtr handleQD = Helper.WindowHelper.WindowFromPoint(windowPoint);
//                    GetMessage(windowPoint, handleQD, chatterName);
//                }
//                Thread.Sleep(2000);

//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError($"{ex.Message} CheckMsgFromWindow for {chatterName}");
//            }
//        }
//        #endregion
//        //窗口相关参数（都是以窗口左上角那点为基准）
//        private int leftPoint = 470;
//        private int downPoint = 170;
//        private int step = 6; // 步长（上下）
//        private int windowHeight = 390;//只是聊天窗体的高度

//        InputSimulator sim = new InputSimulator();
//        private string GetMessage(Point windowPoint, IntPtr hwnd, string chatName)
//        {
//            try
//            {
//                //AppLog.WriteInfo($"{chatName}--窗体左上角为：x:{windowPoint.X},y:{windowPoint.Y}！");
//                int sendMessageCount = 0;
//                int receiveMessageCount = 0;
//                int searchStartX = windowPoint.X + leftPoint; // 发送方起始搜索点的 X 坐标
//                int searchStartY = windowPoint.Y + downPoint; // 发送方起始搜索点的 Y 坐标
//                                                              // Bring the window to the foreground
//                                                              // ShowWindow(hwnd, HWND_TOPMOST);
//                                                              //SetForegroundWindow(hwnd);
//                                                              //SetWindowTopmost(hwnd);                                       //SetForegroundWindow(hwnd);
//                                                              //int pixelInt = 0;
//                                                              //int i = 0;
//                                                              //for (int y = searchStartY; y < searchStartY + windowHeight; y += step)
//                                                              //{
//                                                              //    Point temp1 = new Point(searchStartX, y);
//                                                              //    lock (lock1)
//                                                              //    {
//                                                              //        pixelInt = GetColorRGB(temp1);
//                                                              //    }

//                //    i++;
//                //    if (pixelInt == 16777215)
//                //    {
//                //        searchStartY = y;
//                //        AppLog.WriteInfo($"{chatName}--第一个焦点位置-位置在{i}：x:{searchStartX},y:{y}，颜色：{pixelInt}");
//                //        break;
//                //    }
//                //    //AppLog.WriteInfo($"{chatName}--第{i}个位置：x:{searchStartX},y:{y}，颜色：{pixelInt}");
//                //}

//                // 将屏幕坐标转换为虚拟桌面坐标
//                int virtualScreenX = searchStartX * 65535 / Screen.PrimaryScreen.Bounds.Width;
//                int virtualScreenY = searchStartY * 65535 / Screen.PrimaryScreen.Bounds.Height;

//                // 模拟点击获取焦点
//                sim.Mouse.MoveMouseToPositionOnVirtualDesktop(virtualScreenX, virtualScreenY);
//                sim.Mouse.LeftButtonClick();

//                // 等待点击操作完成
//                Thread.Sleep(20);

//                // 模拟 Ctrl + A 全选
//                sim.Keyboard.ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_A);

//                // 等待全选操作完成
//                Thread.Sleep(20);

//                // 模拟 Ctrl + C 复制
//                sim.Keyboard.ModifiedKeyStroke(VirtualKeyCode.CONTROL, VirtualKeyCode.VK_C);

//                // 等待复制操作完成
//                Thread.Sleep(20);

//                // 再次点击取消焦点
//                sim.Mouse.LeftButtonClick();
//                //Thread.Sleep(200);

//                string clipboardContent = null;
//                Thread staThread = new Thread(
//                                     delegate ()
//                                     {
//                                         try
//                                         {
//                                             // 确保线程在 STA 模式下运行
//                                             if (Thread.CurrentThread.GetApartmentState() != ApartmentState.STA)
//                                             {
//                                                 AppLog.WriteFatal("必须要是STA线程执行啊!");
//                                                 throw new ThreadStateException("The thread must be in STA mode to access the clipboard.");

//                                             }

//                                             // 获取剪贴板的文本内容
//                                             clipboardContent = Clipboard.GetText();
//                                             var ParsedMessage = ParseMessages(clipboardContent);
//                                             // 如果消息被抓取到，调用此方法移除它
//                                             List<string> messages = new List<string>(); // 初始化为一个空列表，以避免 null 引用
//                                             if (ParsedMessage != null)
//                                             {
//                                                 messages = ParsedMessage.Where(o => o.Direction == 0).Select(o => o.ChatMessageInfo).ToList();
//                                             }

//                                             if (messages != null && messages.Count > 0)
//                                             {
//                                                 RemoveMessagesFromDictionary(chatName, messages);
//                                             }

//                                             if (!AllChatDictionary.ContainsKey(chatName))
//                                             {

//                                                 UpdateMessages(chatName, ParsedMessage);
//                                             }
//                                             else
//                                             {
//                                                 UpdateMessages(chatName, ParsedMessage);
//                                             }
//                                         }

//                                         catch (Exception ex)
//                                         {

//                                         }
//                                     });
//                staThread.SetApartmentState(ApartmentState.STA);
//                staThread.Start();
//                staThread.Join();
//                // 写入文件
//                //string fileName = $"{chatName}.txt"; // 文件名为 chatName.txt
//                //string filePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), fileName); // 保存在桌面上

//                //using (StreamWriter writer = new StreamWriter(filePath, false)) // false 表示覆盖已存在的文件，true 表示追加到文件末尾
//                //{
//                //    writer.Write(clipboardContent);
//                //}


//                //AppLog.WriteInfo("聊天人" + chatName + $"共找到{sendMessageCount}个发送方聊天气泡");





//                return "1";
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("聊天人" + chatName + ex.Message + "抓取文本异常");
//            }
//            finally
//            {

//            }
//            return null;
//        }

//        private void RemoveMessagesFromDictionary(string brokerName, List<string> messages)
//        {
//            // 尝试获取当前字典中是否已有该中介名的消息列表
//            if (SendMessagesDictionary.TryGetValue(brokerName, out var existingMessages))
//            {
//                // 从列表中移除所有匹配的消息
//                foreach (var message in messages)
//                {
//                    if (existingMessages.Contains(message))
//                    {
//                        // 如果字典中没有该中介名的条目
//                        AppLog.WriteFatal($"成功移除消息，中介名 - {brokerName} 的消息{message}。");
//                        existingMessages.Remove(message);
//                    }
//                    else
//                    {
//                        // 如果字典中没有该中介名的条目
//                        //AppLog.WriteError($"尝试移除消息，但找不到中介名 - {brokerName} 的消息{message}。");
//                    }
//                }

//                // 如果列表为空，可以从字典中移除该中介名（可选）
//                if (!existingMessages.Any())
//                {
//                    SendMessagesDictionary.TryRemove(brokerName, out _);
//                }

//                // 可选：日志记录，记录消息移除操作
//                //AppLog.WriteInfo($"消息从字典中移除：中介名 - {brokerName}，消息 - {string.Join(", ", messages)}");
//            }
//            else
//            {
//                // 如果字典中没有该中介名的条目
//                //AppLog.WriteError($"尝试移除消息，但找不到中介名 - {brokerName} 的条目。");
//            }
//        }

//        /// <summary>
//        /// 更改逻辑，对接李浩240706
//        /// </summary>
//        /// <param name="chatName"></param>
//        /// <param name="parsedMessages"></param>
//        //private void UpdateMessages(string chatName, List<ChatMessage> parsedMessages)
//        //{
//        //    try
//        //    {
//        //        ///说明重开程序了
//        //        if (parsedMessages == null || !parsedMessages.Any())
//        //        {
//        //            AppLog.WriteError($"parsedMessages 为空或无消息。清空{chatName}");
//        //            if (AllChatDictionary.ContainsKey(chatName))
//        //            {
//        //                AllChatDictionary[chatName].Clear();
//        //                AllChatDictionary.Remove(chatName);
//        //            }
//        //            else
//        //            {
//        //                AllChatDictionary.Remove(chatName);
//        //            }
//        //            return;
//        //        }

//        //        int brokerId = Receivers.Where(o => o.ChatId == chatName).FirstOrDefault()?.Brokerid ?? 0;
//        //        if (brokerId == 0)
//        //        {
//        //            AppLog.WriteError($"无法找到与聊天名称 '{chatName}' 相关的经纪人ID.");
//        //            return;
//        //        }

//        //        if (!AllChatDictionary.ContainsKey(chatName))
//        //        {
//        //            // Step 1: 查询数据库中已有的消息
//        //            var existingMessages = GetRecentMessagesFromDatabase(brokerId);


//        //            // Step 2:获取 parsedMessages 的最小和最大时间
//        //            var parsedMinTime = parsedMessages.First().CreateTime;
//        //            var parsedMaxTime = parsedMessages.Last().CreateTime;


//        //            // 获取数据库中最大时间
//        //            var databaseMaxTime = existingMessages.Max(m => m.CreateTime);

//        //            if (parsedMinTime > databaseMaxTime)
//        //            {
//        //                foreach (var item in parsedMessages)
//        //                {
//        //                    if (item.Direction == 0)
//        //                    {
//        //                        this.SaveMessages(0, item);
//        //                    }
//        //                    else
//        //                    {
//        //                        this.SaveMessages(1, item);
//        //                    }
//        //                    AppLog.WriteWarn("捕捉到新数据" + chatName + item.ChatMessageInfo);
//        //                    this.ChatMessageLog += "名称" + chatName + "，消息：" + item.ChatMessageInfo + "\r\n";

//        //                }
//        //            }
//        //            else if (parsedMaxTime <= databaseMaxTime)
//        //            {
//        //                // 如果解析的消息最大时间都比数据库最大时间小，说明数据库中已经有这些消息，无需操作
//        //                return;
//        //            }
//        //            else
//        //            {
//        //                // 找出需要增量插入的消息（即时间大于数据库最大时间的消息）
//        //                var newMessages = parsedMessages.Where(m => m.CreateTime > databaseMaxTime).ToList();
//        //                if (newMessages.Count > 0)
//        //                {
//        //                    foreach (var item in newMessages)
//        //                    {
//        //                        if (item.Direction == 0)
//        //                        {
//        //                            this.SaveMessages(0, item);
//        //                        }else
//        //                        {
//        //                            this.SaveMessages(1, item);
//        //                        }
//        //                        AppLog.WriteWarn("捕捉到新数据" + chatName + item.ChatMessageInfo);
//        //                        this.ChatMessageLog += "名称" + chatName + "，消息：" + item.ChatMessageInfo + "\r\n";

//        //                    }
//        //                }
//        //            }

//        //            AllChatDictionary[chatName] = parsedMessages;
//        //            return;
//        //        }

//        //        // 获取当前存储的消息列表
//        //        List<ChatMessage> currentMessages = AllChatDictionary[chatName];

//        //        if (currentMessages.Any())
//        //        {

//        //            if (parsedMessages==null|| currentMessages.Count()>parsedMessages.Count())
//        //            {
//        //                AppLog.WriteError($"解析的大于当前字典的内容，说明删除过聊天记录了");
//        //                if (AllChatDictionary.ContainsKey(chatName))
//        //                {
//        //                    AllChatDictionary[chatName].Clear();
//        //                    AllChatDictionary.Remove(chatName);
//        //                }
//        //                else
//        //                {
//        //                    AllChatDictionary.Remove(chatName);
//        //                }
//        //                return;
//        //            }

//        //            // 找到 currentMessages 中最后一条消息的时间戳
//        //            DateTime lastMessageTime = (DateTime)(currentMessages.Last()?.CreateTime);

//        //            // 找到在 parsedMessages 中第一个大于 lastMessageTime 的消息索引
//        //            int newMessageStartIndex = 0;
//        //            for (int i = 0; i < parsedMessages.Count; i++)
//        //            {
//        //                if (parsedMessages[i].CreateTime > lastMessageTime)
//        //                {
//        //                    newMessageStartIndex = i;
//        //                    break;
//        //                }
//        //            }

//        //            if (newMessageStartIndex == 0)//说明找不到
//        //            {
//        //                newMessageStartIndex = currentMessages.Count;
//        //            }
//        //            // 获取新的消息列表
//        //            List<ChatMessage> newMessages = parsedMessages.Skip(newMessageStartIndex).ToList();

//        //            // 处理新消息逻辑
//        //            if (newMessages.Any())
//        //            {
//        //                AppLog.WriteWarn($"捕捉到{newMessages.Count}条新数据");
//        //                foreach (var item in newMessages)
//        //                {
//        //                    AppLog.WriteWarn("捕捉到新数据" + item.ChatMessageInfo);
//        //                    this.ChatMessageLog += "名称" + chatName + "，消息：" + item.ChatMessageInfo + "\r\n";

//        //                }
//        //                // 插入新消息到数据库
//        //                _dailyData.AddChatMessageList(brokerId, newMessages);

//        //                // 更新 currentMessages 列表
//        //                //currentMessages.AddRange(newMessages);
//        //                AllChatDictionary[chatName] = parsedMessages;

//        //                // 发送 WebSocket 消息给客户端和管理员
//        //                SendWebSocketToClientsAndAdmins(brokerId, newMessages);
//        //            }
//        //        }
//        //    }
//        //    catch (Exception ex)
//        //    {
//        //        AppLog.WriteError($"更新消息时发生异常: {ex.Message}");
//        //        // 可以选择在这里处理异常，例如记录日志或者通知用户
//        //    }
//        //}
//        // 修改 UpdateMessages 方法
//        private void UpdateMessages(string chatName, List<ChatMessage> parsedMessages)
//        {
//            try
//            {
//                // 说明重开程序了
//                if (parsedMessages == null || !parsedMessages.Any())
//                {
//                    AppLog.WriteError($"parsedMessages 为空或无消息。清空{chatName}");
//                    AllChatDictionary.TryRemove(chatName, out _);
//                    return;
//                }

//                int brokerId = Receivers.Where(o => o.ChatId == chatName).FirstOrDefault()?.Brokerid ?? 0;
//                if (brokerId == 0)
//                {
//                    AppLog.WriteError($"无法找到与聊天名称 '{chatName}' 相关的经纪人ID.");
//                    return;
//                }

//                if (!AllChatDictionary.ContainsKey(chatName))
//                {
//                    // Step 1: 查询数据库中已有的消息
//                    var existingMessages = GetRecentMessagesFromDatabase(brokerId);

//                    // Step 2:获取 parsedMessages 的最小和最大时间
//                    var parsedMinTime = parsedMessages.First().CreateTime;
//                    var parsedMaxTime = parsedMessages.Last().CreateTime;

//                    // 获取数据库中最大时间
//                    var databaseMaxTime = existingMessages.Max(m => m.CreateTime);

//                    if (parsedMinTime > databaseMaxTime)
//                    {
//                        foreach (var item in parsedMessages)
//                        {
//                            short direction = item.Direction.GetValueOrDefault();

//                            if (direction == 1 && item.BrokerName == chatName) //只保存中介消息
//                            {
//                                item.BrokerId = brokerId;
//                                SaveMessageToLily(direction, item);
//                            }

//                            AppLog.WriteWarn($"捕捉到新数据 {chatName} {item.ChatMessageInfo}");
//                            //ChatMessageLog += $"名称 {chatName}，消息：{item.ChatMessageInfo}\r\n";
//                        }
//                    }
//                    else if (parsedMaxTime <= databaseMaxTime)
//                    {
//                        // 如果解析的消息最大时间都比数据库最大时间小，说明数据库中已经有这些消息，无需操作
//                        return;
//                    }
//                    else
//                    {
//                        // 找出需要增量插入的消息（即时间大于数据库最大时间的消息）
//                        var newMessages = parsedMessages.Where(m => m.CreateTime > databaseMaxTime).ToList();
//                        if (newMessages.Count > 0)
//                        {
//                            foreach (var item in newMessages)
//                            {

//                                short direction = item.Direction.GetValueOrDefault();
//                                if (direction == 1 && item.BrokerName == chatName) //只保存中介消息
//                                {
//                                    item.BrokerId = brokerId;
//                                    SaveMessageToLily(direction, item);
//                                }
//                                AppLog.WriteWarn($"捕捉到新数据 {chatName} {item.ChatMessageInfo}");
//                                //ChatMessageLog += $"名称 {chatName}，消息：{item.ChatMessageInfo}\r\n";
//                            }
//                        }
//                    }

//                    AllChatDictionary.TryAdd(chatName, parsedMessages);
//                    return;
//                }

//                // 获取当前存储的消息列表
//                if (AllChatDictionary.TryGetValue(chatName, out List<ChatMessage> currentMessages))
//                {
//                    if (parsedMessages == null || currentMessages.Count() > parsedMessages.Count())
//                    {
//                        AppLog.WriteError($"解析的大于当前字典的内容，说明删除过聊天记录了");
//                        AllChatDictionary.TryRemove(chatName, out _);
//                        return;
//                    }

//                    // 找到 currentMessages 中最后一条消息的时间戳
//                    DateTime lastMessageTime = (DateTime)currentMessages.Last().CreateTime;

//                    // 找到在 parsedMessages 中第一个大于 lastMessageTime 的消息索引
//                    int newMessageStartIndex = 0;
//                    for (int i = 0; i < parsedMessages.Count; i++)
//                    {
//                        if (parsedMessages[i].CreateTime > lastMessageTime)
//                        {
//                            newMessageStartIndex = i;
//                            break;
//                        }
//                    }

//                    if (newMessageStartIndex == 0)
//                    {
//                        newMessageStartIndex = currentMessages.Count;
//                    }

//                    // 获取新的消息列表
//                    List<ChatMessage> newMessages = parsedMessages.Skip(newMessageStartIndex).ToList();

//                    // 处理新消息逻辑
//                    if (newMessages.Any())
//                    {
//                        AppLog.WriteWarn($"捕捉到{newMessages.Count}条新数据");
//                        foreach (var item in newMessages)
//                        {
//                            short direction = item.Direction.GetValueOrDefault();

//                            if (direction == 1 && item.BrokerName == chatName) //只保存中介消息
//                            {
//                                item.BrokerId = brokerId;
//                                SaveMessageToLily(direction, item);
//                            }
//                            //AppLog.WriteWarn($"捕捉到新数据 {chatName} {item.ChatMessageInfo}");
//                            //ChatMessageLog += $"名称 {chatName}，消息：{item.ChatMessageInfo}\r\n";
//                            AppLog.WriteWarn($"捕捉到新数据 {item.ChatMessageInfo}");
//                            //ChatMessageLog += $"名称 {chatName}，消息：{item.ChatMessageInfo}\r\n";
//                        }

//                        // 插入新消息到数据库
//                        //_dailyData.AddChatMessageList(brokerId, newMessages);

//                        // 更新 currentMessages 列表
//                        AllChatDictionary.TryUpdate(chatName, parsedMessages, currentMessages);

//                        // 发送 WebSocket 消息给客户端和管理员
//                        //SendWebSocketToClientsAndAdmins(brokerId, newMessages);
//                    }
//                }
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError($"更新消息时发生异常: {ex.Message}");
//                // 可以选择在这里处理异常，例如记录日志或者通知用户
//            }
//        }



//        /// <summary>
//        /// 增量式查找（默认找到最近连续的五条消息就说明到头了）然后可以对新增的进行插入操作
//        /// </summary>
//        /// <param name="chatName"></param>
//        /// <param name="parsedMessage"></param>
//        /// <exception cref="NotImplementedException"></exception>
//        /// 
//        //private void UpdateMessages(string chatName, List<ChatMessage> parsedMessages)
//        //{
//        //    try
//        //    {
//        //        ///说明重开程序了
//        //        if (parsedMessages == null || !parsedMessages.Any())
//        //        {
//        //            AppLog.WriteError($"parsedMessages 为空或无消息。清空{chatName}");
//        //            if (AllChatDictionary.ContainsKey(chatName))
//        //            {
//        //                AllChatDictionary[chatName].Clear();
//        //                AllChatDictionary.Remove(chatName);
//        //            }
//        //            else
//        //            {
//        //                AllChatDictionary.Remove(chatName);
//        //            }
//        //            return;
//        //        }

//        //        int brokerId = Receivers.Where(o => o.ChatId == chatName).FirstOrDefault()?.Brokerid ?? 0;
//        //        if (brokerId == 0)
//        //        {
//        //            AppLog.WriteError($"无法找到与聊天名称 '{chatName}' 相关的经纪人ID.");
//        //            return;
//        //        }

//        //        if (!AllChatDictionary.ContainsKey(chatName))
//        //        {
//        //            // Step 1: 查询数据库中已有的消息
//        //            var existingMessages = GetRecentMessagesFromDatabase(brokerId);
//        //            // Step 2: 使用HashSet或Dictionary存储已有消息
//        //            //var existingMessagesSet = new HashSet<(string ChatMessage, DateTime? Time)>(existingMessages
//        //            //    .Select(em => (em.ChatMessageInfo.Replace("\r", ""), em.CreateTime)));
//        //            var processedMessages = existingMessages
//        //              .Select(em => (ChatMessage: em.ChatMessageInfo.Replace("\r", ""), Time: em.CreateTime))
//        //              .ToList();
//        //            // 第二步：处理消息内容，但不去重

//        //            // Step 3: 确定时间范围
//        //            var startTime = parsedMessages.First().CreateTime;
//        //            var endTime = parsedMessages.Last().CreateTime;

//        //            // Step 4: 删除时间范围内的消息
//        //            //DeleteMessagesFromDatabase(brokerId, startTime, endTime);
//        //            AppLog.WriteInfo($"删除{startTime}至{endTime}的db数据");
//        //            // Step 4: 检查新消息并找出未存在的消息
//        //            //var newChatMessages = new List<ChatMessage>();
//        //            //foreach (var parsedMessage in parsedMessages)
//        //            //{
//        //            //    var key = (parsedMessage.ChatMessageInfo, parsedMessage.CreateTime);
//        //            //    if (!processedMessages.Contains(key))
//        //            //    {
//        //            //        newChatMessages.Add(parsedMessage);
//        //            //    }
//        //            //}

//        //            // Step 4: 批量插入新数据
//        //            if (parsedMessages.Any())
//        //            {
//        //                AppLog.WriteWarn($"捕捉到{parsedMessages.Count}条新数据");
//        //                foreach (var item in parsedMessages)
//        //                {
//        //                    if(item.Direction==0)
//        //                    {
//        //                        this.SaveMessages(0, item);
//        //                    }
//        //                    AppLog.WriteWarn("捕捉到新数据" + chatName + item.ChatMessageInfo);
//        //                    this.ChatMessageLog += "名称" + chatName + "，消息：" + item.ChatMessageInfo + "\r\n";

//        //                }


//        //                //_dailyData.AddChatMessageList(brokerId, parsedMessages); 改成调李浩接口

//        //                //web通过socket发送给管理端和客户端更新数据
//        //                SendWebSocketToClientsAndAdmins(brokerId, parsedMessages);
//        //            }
//        //            AllChatDictionary[chatName] = parsedMessages;
//        //            return;
//        //        }

//        //        // 获取当前存储的消息列表
//        //        List<ChatMessage> currentMessages = AllChatDictionary[chatName];
//        //        // 确保 currentMessages 至少有一条消息(重开了可能）
//        //        //if(parsedMessages==null||parsedMessages.Count<=currentMessages.Count)
//        //        //{
//        //        //    if (AllChatDictionary.ContainsKey(chatName))
//        //        //    {
//        //        //        AllChatDictionary[chatName].Clear();
//        //        //        AllChatDictionary.Remove(chatName);
//        //        //    }
//        //        //    else
//        //        //    {
//        //        //        AllChatDictionary.Remove(chatName);
//        //        //    }
//        //        //    //说明没有新消息
//        //        //    return;
//        //        //}

//        //        if (currentMessages.Any())
//        //        {
//        //            // 找到 currentMessages 中最后一条消息的时间戳
//        //            DateTime lastMessageTime = (DateTime)(currentMessages.Last()?.CreateTime);

//        //            // 找到在 parsedMessages 中第一个大于 lastMessageTime 的消息索引
//        //            int newMessageStartIndex = 0;
//        //            for (int i = 0; i < parsedMessages.Count; i++)
//        //            {
//        //                if (parsedMessages[i].CreateTime > lastMessageTime)
//        //                {
//        //                    newMessageStartIndex = i;
//        //                    break;
//        //                }
//        //            }

//        //            if (newMessageStartIndex == 0)//说明找不到
//        //            {
//        //                newMessageStartIndex = currentMessages.Count;
//        //            }
//        //            // 获取新的消息列表
//        //            List<ChatMessage> newMessages = parsedMessages.Skip(newMessageStartIndex).ToList();

//        //            // 处理新消息逻辑
//        //            if (newMessages.Any())
//        //            {
//        //                AppLog.WriteWarn($"捕捉到{newMessages.Count}条新数据");
//        //                foreach (var item in newMessages)
//        //                {
//        //                    AppLog.WriteWarn("捕捉到新数据" + item.ChatMessageInfo);
//        //                    this.ChatMessageLog += "名称" + chatName + "，消息：" + item.ChatMessageInfo + "\r\n";

//        //                }
//        //                // 插入新消息到数据库
//        //                _dailyData.AddChatMessageList(brokerId, newMessages);

//        //                // 更新 currentMessages 列表
//        //                //currentMessages.AddRange(newMessages);
//        //                AllChatDictionary[chatName] = parsedMessages;

//        //                // 发送 WebSocket 消息给客户端和管理员
//        //                SendWebSocketToClientsAndAdmins(brokerId, newMessages);
//        //            }
//        //        }
//        //    }
//        //    catch (Exception ex)
//        //    {
//        //        AppLog.WriteError($"更新消息时发生异常: {ex.Message}");
//        //        // 可以选择在这里处理异常，例如记录日志或者通知用户
//        //    }
//        //}

//        private void DeleteMessagesFromDatabase(int brokerId, DateTime? startTime, DateTime? endTime)
//        {
//            try
//            {
//                _dailyData.DelChatMessageListByCreateTime(brokerId, startTime, endTime);
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError(ex.Message + ex.StackTrace + "异常：DeleteMessagesFromDatabase");
//            }
//        }

//        //private void UpdateMessages(string chatName, List<ChatMessage> parsedMessages)
//        //{
//        //    int brokerId = (int)Receivers.Where(o => o.ChatId == chatName).FirstOrDefault().Brokerid;
//        //    if (!AllChatDictionary.ContainsKey(chatName))
//        //    {
//        //        // Step 1: 查询数据库中已有的消息
//        //        var existingMessages = GetRecentMessagesFromDatabase(brokerId);
//        //        // Step 2: 使用HashSet或Dictionary存储已有消息
//        //        var existingMessagesSet = new HashSet<(string ChatMessage, DateTime? Time)>(existingMessages
//        //            .Select(em => (em.ChatMessageInfo, em.CreateTime)));

//        //        // Step 3: 检查新消息并找出未存在的消息
//        //        var newChatMessages = new List<ChatMessage>();
//        //        foreach (var parsedMessage in parsedMessages)
//        //        {
//        //            var key = (parsedMessage.ChatMessageInfo, parsedMessage.CreateTime);
//        //            if (!existingMessagesSet.Contains(key))
//        //            {
//        //                newChatMessages.Add(parsedMessage);
//        //            }
//        //        }

//        //        // Step 4: 批量插入新数据
//        //        if (newChatMessages.Any())
//        //        {
//        //            AppLog.WriteWarn($"捕捉到{newChatMessages.Count}条新数据");
//        //            foreach (var item in newChatMessages)
//        //            {
//        //                AppLog.WriteWarn("捕捉到新数据" + item.ChatMessageInfo);
//        //            }
//        //            _dailyData.AddChatMessageList(brokerId, newChatMessages);


//        //            //web通过socket发送给管理端和客户端更新数据
//        //            SendWebSocketToClientsAndAdmins(brokerId,newChatMessages);
//        //        }
//        //        AllChatDictionary[chatName] = parsedMessages;
//        //        return;
//        //    }

//        //    // 获取当前存储的消息列表

//        //    List<ChatMessage> currentMessages = AllChatDictionary[chatName];
//        //    // 确保 currentMessages 至少有一条消息
//        //    if (currentMessages.Any())
//        //    {
//        //        // 找到 currentMessages 中最后一条消息的时间戳
//        //        DateTime lastMessageTime = (DateTime)(currentMessages.Last()?.CreateTime);

//        //        // 找到在 parsedMessages 中第一个大于 lastMessageTime 的消息索引
//        //        int newMessageStartIndex = 0;
//        //        for (int i = 0; i < parsedMessages.Count; i++)
//        //        {
//        //            if (parsedMessages[i].CreateTime > lastMessageTime)
//        //            {
//        //                newMessageStartIndex = i;
//        //                break;
//        //            }
//        //        }

//        //        if(newMessageStartIndex==0)//说明找不到
//        //        {
//        //            newMessageStartIndex = currentMessages.Count;
//        //        }
//        //        // 获取新的消息列表
//        //        List<ChatMessage> newMessages = parsedMessages.Skip(newMessageStartIndex).ToList();

//        //        // 处理新消息逻辑
//        //        if (newMessages.Any())
//        //        {
//        //            AppLog.WriteWarn($"捕捉到{newMessages.Count}条新数据");
//        //            foreach (var item in newMessages)
//        //            {
//        //                AppLog.WriteWarn("捕捉到新数据" + item.ChatMessageInfo);
//        //            }
//        //            // 插入新消息到数据库
//        //            _dailyData.AddChatMessageList(brokerId, newMessages);

//        //            // 更新 currentMessages 列表
//        //            //currentMessages.AddRange(newMessages);
//        //            AllChatDictionary[chatName] = parsedMessages;

//        //            // 发送 WebSocket 消息给客户端和管理员
//        //            SendWebSocketToClientsAndAdmins(brokerId, newMessages);
//        //        }
//        //    }

//        //    //// Get new messages to insert
//        //    //List<ChatMessage> newMessages = parsedMessages.Skip(newMessageStartIndex).ToList();

//        //    //if (newMessages.Any())
//        //    //{
//        //    //    // Insert new messages to database
//        //    //    InsertNewMessagesToDatabase(chatName, newMessages);

//        //    //    // Update current messages list
//        //    //    currentMessages.AddRange(newMessages);
//        //    //    AllChatDictionary[chatName] = currentMessages;

//        //    //    // Optional: Send messages through WebSocket
//        //    //    SendWebSocketToClientsAndAdmins(brokerId, newMessages);
//        //    //}
//        //}

//        /// <summary>
//        /// 把消息广播出去
//        /// </summary>
//        /// <param name="brokerId"></param>
//        /// <param name="newChatMessages"></param>
//        /// <exception cref="NotImplementedException"></exception>
//        private void SendWebSocketToClientsAndAdmins(int brokerId, List<ChatMessage> newChatMessages)
//        {
//            //web通过socket发送给管理端和客户端
//            try
//            {
//                QuanYiOrderServerResponseClass QSR = new QuanYiOrderServerResponseClass();
//                QSR.DataType = QuanYiServerBaseClass.DataTypeEnum.NewChatMessageIn;
//                QSR.NewChatMessageList = newChatMessages;
//                this.serverWebSocketFromAdmin?.SendMessageToAdmins(QSR);
//                this.serverWebSocketFromClient?.SendMessageToClients(QSR);
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("SendWebSocketToClientsAndAdmins异常" + ex.Message);
//            }

//        }

//        private void InsertNewMessagesToDatabase(string chatName, List<ChatMessage> newMessages)
//        {
//            //db.ChatMessages.AddRange(newMessages);
//            //db.SaveChanges();
//        }
//        /// <summary>
//        /// 初始化消息方法，找到变化的
//        /// </summary>
//        /// <param name="chatName"></param>
//        private void InitializeMessages(string chatName)
//        {
//            //if (!AllChatDictionary.ContainsKey(chatName))
//            //{
//            //    List<Message> initialMessages = db.ChatMessages
//            //        .Where(o => o.ChatName == chatName)
//            //        .OrderBy(a => a.CreateTime)
//            //        .ToList();

//            //    AllChatDictionary[chatName] = initialMessages;
//            //}
//        }


//        /// <summary>
//        /// 获取数据库最近的五条消息
//        /// </summary>
//        /// <param name="chatName"></param>
//        /// <param name="v"></param>
//        /// <returns></returns>
//        /// <exception cref="NotImplementedException"></exception>
//        private List<ChatMessage> GetRecentMessagesFromDatabase(int brokerId, int number = 0)
//        {
//            List<ChatMessage> messageList = new List<ChatMessage>();
//            try
//            {
//                messageList = _dailyData.GetRecentMessagesByBrokerName(brokerId, number);
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("GetRecentMessagesFromDatabase异常" + ex.Message + ex.StackTrace);
//            }

//            return messageList; // 确保在所有情况下都有返回值
//        }

//        public List<ChatMessage> ParseMessages(string input)
//        {
//            try
//            {
//                List<ChatMessage> messages = new List<ChatMessage>();


//                string[] lines = input.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
//                ChatMessage currentMessage = null;

//                bool isQuoteMessage = false;
//                foreach (string line in lines)
//                {
//                    string trimmedLine = line.Trim();
//                    // Check if the line starts with a sender and timestamp
//                    if (IsSenderTimestampLine(line)) //判断是时间戳和发送人
//                    {
//                        // If there is an existing message, add it to the list
//                        if (currentMessage != null)
//                        {

//                            currentMessage.ChatMessageInfo = currentMessage.ChatMessageInfo.TrimEnd('\r');

//                            if (isQuoteMessage)
//                            {
//                                currentMessage.ChatMessageInfo += "(回复内容）";
//                                isQuoteMessage = false;
//                            }
//                            messages.Add(currentMessage);
//                        }

//                        // Create a new message
//                        currentMessage = new ChatMessage();
//                        string[] parts = line.Split(new[] { ' ' }, 3);
//                        if (parts.Length < 3)
//                        {
//                            continue;
//                        }
//                        string timestampPart = parts[2].TrimEnd('\r');  // 去掉 '\r'
//                        currentMessage.BrokerName = parts[0];
//                        // 假设 parts[0] 是用来查找的目标值
//                        var targetReceiverExists = Receivers.Any(o => o.ChatId == parts[0]);


//                        // 判断时间戳部分是否为正确的时间格式，并且第二部分为空时，设定为今天的日期
//                        if (DateTime.TryParseExact(timestampPart, "HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out _))
//                        {
//                            if (string.IsNullOrEmpty(parts[1]))
//                            {
//                                parts[1] = DateTime.Today.ToString("yyyy/M/d");
//                            }
//                        }
//                        else if (parts[1] == "")
//                        {
//                            parts[1] = DateTime.Today.ToString("yyyy/M/d");
//                        }
//                        // 根据是否找到匹配项设置 currentMessage.Direction 的值
//                        currentMessage.Direction = (short?)(targetReceiverExists ? 1 : 0);
//                        string dateTimeStr = $"{parts[1]} {timestampPart}";
//                        DateTime dateTime1;
//                        if (DateTime.TryParseExact(dateTimeStr, "yyyy/M/d H:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime1))
//                        {
//                            currentMessage.CreateTime = dateTime1;
//                        }
//                        else
//                        {
//                            AppLog.WriteError($"日期解析失败 '{dateTimeStr}' as DateTime.");
//                            // 如果解析失败，可以进行相应的处理，比如记录日志或者设定一个默认时间
//                            Console.WriteLine($"Failed to parse '{dateTimeStr}' as DateTime.");
//                        }

//                        currentMessage.ChatMessageInfo = string.Empty;
//                    }
//                    else  //是内容消息（记得区分 引用和非引用）
//                    {
//                        // 处理消息内容
//                        if (currentMessage != null)
//                        {


//                            trimmedLine = line.TrimEnd('\r'); // 去掉行末的 '\r'
//                            if (!string.IsNullOrEmpty(currentMessage.ChatMessageInfo))
//                            {
//                                currentMessage.ChatMessageInfo += "\r"; // 换行符
//                            }

//                            currentMessage.ChatMessageInfo += trimmedLine;

//                            if (isQuoteMessage)
//                            {
//                                currentMessage.ChatMessageInfo += "\r";
//                                currentMessage.QuoteMessage = trimmedLine;

//                                ///找是否是引用消息？
//                                int yinYongCount = 0;
//                                if (SelectMessageInMessages(trimmedLine, messages))
//                                {
//                                    currentMessage.ChatMessageInfo += "\r\n";
//                                    isQuoteMessage = true;
//                                }
//                                else
//                                {
//                                    isQuoteMessage = false;
//                                    currentMessage.ChatMessageInfo += "【回复消息】（系统判断）：\r";
//                                }

//                            }

//                            if ((trimmedLine.StartsWith("吴忠贤") || trimmedLine.StartsWith("钟长明") || trimmedLine.StartsWith("谷苏")))
//                            {
//                                currentMessage.IsQuote = true;  // 第一行是引用消息
//                                isQuoteMessage = true;
//                                currentMessage.ChatMessageInfo += "\r\n【引用消息】（系统判断）：\r";
//                                // 设置引用消息格式
//                            }

//                        }
//                        //// Append to the current message's content
//                        //string trimline = line.Replace("\r", "");
//                        //if (currentMessage != null)
//                        //{
//                        //    if (!string.IsNullOrEmpty(currentMessage.ChatMessageInfo))
//                        //    {
//                        //        currentMessage.ChatMessageInfo += trimline+="  ";
//                        //    }
//                        //    else
//                        //    {
//                        //        currentMessage.ChatMessageInfo += trimmedLine;
//                        //        // Check if the first line of content indicates a quoted message
//                        //        if (trimmedLine.StartsWith("钟长明") || trimmedLine.StartsWith("谷苏") || trimmedLine.StartsWith("吴忠贤"))
//                        //        {
//                        //            currentMessage.QuoteMessage = "是引用消息";
//                        //            currentMessage.ChatMessageInfo += "(引用消息）——";
//                        //        }
//                        //    }
//                        //}
//                    }
//                }

//                // Add the last message if any
//                if (currentMessage != null)
//                {
//                    if (isQuoteMessage)
//                    {
//                        isQuoteMessage = false;
//                    }
//                    currentMessage.ChatMessageInfo = currentMessage.ChatMessageInfo.TrimEnd('\r');
//                    messages.Add(currentMessage);
//                }
//                return messages;
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("解析消息list异常" + ex.Message);
//            }
//            return null;
//        }

//        /// <summary>
//        /// 判断是否是引用消息
//        /// </summary>
//        /// <param name="trimmedLine"></param>
//        /// <param name="messages"></param>
//        /// <returns></returns>
//        /// <exception cref="NotImplementedException"></exception>
//        private bool SelectMessageInMessages(string trimmedLine, List<ChatMessage> messages)
//        {
//            if (messages.Where(o => o.ChatMessageInfo.Contains(trimmedLine)).Count() > 1)
//            {
//                return true;
//            }
//            else
//            {
//                return false;
//            }
//        }

//        bool IsValidDateTime(string dateTimeString)
//        {
//            return DateTime.TryParseExact(dateTimeString, "yyyy/M/d H:mm:ss",
//                                          System.Globalization.CultureInfo.InvariantCulture,
//                                          System.Globalization.DateTimeStyles.None, out _);
//        }
//        //private static bool IsSenderTimestampLine(string line)
//        //{

//        //    string[] parts = line.Split(' ');
//        //    if (parts.Length >= 3)
//        //    {
//        //        DateTime temp;
//        //        bool result = DateTime.TryParseExact($"{parts[1]} {parts[2]}".TrimEnd('\r'), "yyyy/M/d HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out temp);
//        //        return result;
//        //    }
//        //    return false;
//        //}
//        private bool IsSenderTimestampLine(string line)
//        {
//            string[] parts = line.Split(new char[] { ' ', '\r' }, StringSplitOptions.RemoveEmptyEntries);


//            // Check if line has at least 3 parts for the first format
//            if (parts.Length >= 3)
//            {
//                // Format: 吴忠贤 2024/6/25 13:00:38
//                string dateString = $"{parts[1]} {parts[2]}";
//                //bool isTime = DateTime.TryParse(dateString, out _);

//                //return isTime;

//                //bool isExactMatch = DateTime.TryParseExact(dateString, "yyyy/M/d H:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
//                bool isExactMatch = DateTime.TryParseExact(dateString, "yyyy/M/d H:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
//                return isExactMatch;
//            }
//            else if (parts.Length == 2)
//            {
//                // Format: 吴忠贤  9:13:21 (Assuming today's date for the missing date part)
//                string timePart = parts[1].Trim(); // Remove leading and trailing spaces

//                bool isTime = DateTime.TryParse(timePart, out _);
//                bool isBroker = IsChatName(parts[0].Trim());
//                bool result = isTime & isBroker;
//                return result;
//            }

//            //else if (parts.Length == 2)
//            //{
//            //    string dateString = $"{DateTime.Today.ToString("yyyy/M/d")} {parts[1].PadLeft(8, '0')}"; // Ensure time part has HH:mm:ss format
//            //    bool temp1= DateTime.TryParseExact(dateString, "yyyy/M/d HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out _);

//            //    this.OrderLog+=$"特殊时间+{line}+返回+{temp1}"+"\r\n";
//            //    return DateTime.TryParseExact(dateString, "yyyy/M/d HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
//            //    //string dateString = $"{DateTime.Today.ToString("yyyy/M/d")} {parts[1]}";
//            //    //return DateTime.TryParseExact(dateString, "yyyy/M/d HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
//            //}

//            return false;
//        }

//        private bool IsChatName(string chatname)
//        {
//            try
//            {
//                if (BrokerList.Contains(chatname) || chatname == "吴忠贤")
//                {
//                    return true;
//                }
//                else
//                {
//                    return false;
//                }
//            }
//            catch (Exception ex)
//            {
//                return false;
//            }

//        }

//        private int GetColorRGB(Point p)
//        {
//            IntPtr hdc = Helper.WindowHelper.GetDC(new IntPtr(0));//取到设备场景(0就是全屏的设备场景) 
//            int color = Helper.WindowHelper.GetPixel(hdc, p);//取指定点颜色 
//            Helper.WindowHelper.ReleaseDC(IntPtr.Zero, hdc);
//            return color;

//        }
//        #endregion

//        #region 强制关闭和重启
//        private GlobalHotKeyManager _hotKeyManager;
//        private void RegisterHotKey()
//        {
//            _hotKeyManager = new GlobalHotKeyManager();
//            _hotKeyManager.OnHotKeyPressed += ToggleCapture;
//            // 注册热键
//            _hotKeyManager.RegisterGlobalHotKey(PrismApplication.Current.MainWindow);
//        }

//        private void ToggleCapture()
//        {
//            if (IsCapture)
//            {
//                IsCapture = false;
//                Growl.SuccessGlobal("成功停止扫描");
//            }
//            else
//            {
//                IsCapture = true;
//                Growl.SuccessGlobal("成功开启扫描");
//            }
//        }
//        public void StopCapture()
//        {
//            if (!_isRunning)
//            {
//                Growl.SuccessGlobal("任务没有运行。");
//                return;
//            }

//            // 取消任务
//            _cancellationTokenSource?.Cancel();
//            // 让任务有时间响应取消请求
//            _cancellationTokenSource?.Dispose();

//            _cancellationTokenSource = null;
//            // 等待任务完成
//            // 确保任务对象非 null 并且等待任务完成
//            if (_captureTask != null)
//            {
//                try
//                {
//                    // 等待任务完成，处理可能抛出的异常
//                    _captureTask.Wait();
//                }
//                catch (AggregateException ex)
//                {
//                    // 处理任务中的异常
//                    foreach (var innerException in ex.InnerExceptions)
//                    {
//                        // 处理每个内部异常
//                        Console.WriteLine(innerException.Message);
//                    }
//                }
//                catch (TaskCanceledException)
//                {
//                    // 处理任务被取消的情况
//                    Console.WriteLine("任务已取消。");
//                }
//                catch (Exception ex)
//                {
//                    // 处理其他异常
//                    Console.WriteLine(ex.Message);
//                }
//                finally
//                {
//                    _isRunning = false;

//                }
//            }


//            // 在成功停止任务后，可以使用 Growl 或其他方式提示用户
//            Growl.SuccessGlobal("成功关闭扫描QTRADE");
//        }
//        private void StopTimer()
//        {
//            if (timer != null && timer.Enabled)
//            {
//                Growl.SuccessGlobal("成功关闭扫描QTRADE");
//                timer.Stop();
//                AppLog.WriteInfo("Timer stopped by Ctrl+M");
//            }
//            else
//            {
//                Growl.SuccessGlobal("成功开启QTRADE服务");
//                timer?.Start();
//                AppLog.WriteInfo("Timer stopped by Ctrl+M");
//            }
//        }

//        private void StopCature()
//        {
//            // 取消任务 Growl.SuccessGlobal("成功关闭扫描QTRADE");
//            _cancellationTokenSource?.Cancel();
//        }

//        #endregion

//        #region 对接刘-服务端（http接口）

//        public const string ChannelId = "f09639756a47415fb4fbf6d31febbad4";
//        /// <summary>
//        /// 0代表用户消息，1代表中介消息
//        /// </summary>
//        /// <param name="i"></param>
//        private async void SaveMessageToLily(short i, ChatMessage chatMessage)
//        {
//            try
//            {
//                if (i == 0)
//                {
//                    using (var client = new HttpClient())
//                    {
//                        // 创建一个包含用户ID的匿名对象
//                        var data = new
//                        {
//                            chatId = chatMessage.ChatId,
//                            message = chatMessage.ChatMessageInfo,
//                            brokerId = chatMessage.BrokerId,
//                            channelId = ChannelId,
//                            direction = 0,
//                            tradeId = chatMessage.TradeId ?? null,
//                            createTime = chatMessage.CreateTime
//                        };

//                        var request = new HttpRequestMessage(HttpMethod.Post, $"{DataHelper.BaseConfig.HttpUrl}/chatMessage/pro/send");

//                        request.Headers.Add("Authorization", UserHelper.Token);
//                        var json = JsonConvert.SerializeObject(data);
//                        var content = new StringContent(json, Encoding.UTF8, "application/json");

//                        request.Content = content;

//                        var response = await client.SendAsync(request);
//                        //var tmp = response.Content.ReadAsStringAsync().Result;
//                        response.EnsureSuccessStatusCode();
//                        AppLog.WriteFatal($"捕获到下单消息,时间{data.createTime},中介：{data.brokerId},消息：{data.message}");
//                        PrismApplication.Current.Dispatcher.Invoke(() =>
//                        {
//                            ChatMessageLog += "发给lily端-用户下单  " + $"中介：{data.brokerId}" +
//                            chatMessage.ChatMessageInfo + DateTime.Now + "  \r\n";
//                        });

//                    }
//                }
//                else
//                {
//                    using (var client = new HttpClient())
//                    {
//                        // 创建一个包含用户ID的匿名对象，中介端没有 chatId 和 tradeId
//                        var data = new
//                        {
//                            message = chatMessage.ChatMessageInfo,
//                            brokerId = chatMessage.BrokerId,
//                            channelId = ChannelId,
//                            direction = 1,
//                            createTime = (DateTime?)null,
//                        };

//                        using (var request = new HttpRequestMessage(HttpMethod.Post, $"{DataHelper.BaseConfig.HttpUrl}/chatMessage/pro/send"))
//                        {
//                            request.Headers.Add("Authorization", UserHelper.Token);
//                            var json = JsonConvert.SerializeObject(data);
//                            var content = new StringContent(json, Encoding.UTF8, "application/json");
//                            request.Content = content;

//                            AppLog.WriteFatal($"捕获到中介消息,时间{data.createTime},中介：{data.brokerId},消息：{data.message}");

//                            using (var response = await client.SendAsync(request))
//                            {
//                                //var tmp = response.Content.ReadAsStringAsync().Result;
//                                response.EnsureSuccessStatusCode();
//                            }
//                        }

//                        PrismApplication.Current.Dispatcher.Invoke(() =>
//                        {
//                            ChatMessageLog += "发给lily端-中介回复  " + chatMessage.ChatMessageInfo + DateTime.Now + "  \r\n";
//                        });


//                    }

//                }
//            }
//            catch (Exception ex)
//            {
//                AppLog.WriteError("SaveMessageToLily异常" + ex.Message + ex.StackTrace);
//            }

//        }
//        #endregion
//    }
//}
